Momentum
A library for solving nonlinear optimization problems related to human body kinematics
Loading...
Searching...
No Matches
momentum Namespace Reference

Namespaces

namespace  detail
 
namespace  io_detail
 

Classes

class  AccelerationSequenceErrorFunctionT
 Error function that penalizes the acceleration of joint positions across three consecutive frames using a standard finite difference stencil [1, -2, 1]. More...
 
struct  AimDataT
 Aim constraint data: a local ray (point, dir) passes a global point target. More...
 
class  AimDirErrorFunctionT
 The AimDirErrorFunction computes the element-wise differences between the normalized aim vector and the ray direction. More...
 
class  AimDistErrorFunctionT
 The AimDistErrorFunction computes the distance from the aim target point to an aim ray (an original and a positive direction). More...
 
class  AlignedAllocator
 An allocator that aligns memory blocks according to a specified alignment. More...
 
struct  AlignedDeleter
 Custom deleter for aligned memory. More...
 
struct  BaseConfig
 Common configuration for a tracking problem. More...
 
struct  BlendShape
 Skinning class that combines blend shape vectors with a base shape. More...
 
struct  BlendShapeBase
 Skinning class that manages blend shape vectors/offsets. More...
 
struct  BlendWeightsT
 
struct  BoneWeightT
 
struct  CalibrationConfig
 Configuration for running body and/or locator calibration. More...
 
struct  CandidateTriangle
 Represents a candidate triangle for sliding constraints. More...
 
struct  CharacterParametersT
 A struct that encapsulates both pose and identity parameters for a character. More...
 
struct  CharacterStateT
 Represents the complete state of a character at a specific point in time. More...
 
struct  CharacterT
 A character model with skeletal structure, mesh, and optional components. More...
 
class  CollisionErrorFunctionStatelessT
 NOTE: This is a resurrected version of the CollisionErrorFunction (previously updated by D50818775). More...
 
class  CollisionErrorFunctionT
 
struct  CollisionGeometryStateT
 Represents collision geometry states using a Structure of Arrays (SoA) format. More...
 
class  ColumnIndexedMatrix
 
struct  ConstraintData
 Base structure of constraint data. More...
 
class  ConstraintErrorFunctionT
 The ConstraintErrorFunction is a base class of a general form of constraint errors l = w * loss(f^2), where w is the weight (could be a product of different weighting terms), loss() is the generalized loss function (see math/generalized_loss.h), and f is a difference vector we want to minimize. More...
 
struct  DeduceSpanType
 A utility struct that facilitates the deduction of a std::span type from a given type. More...
 
struct  DistanceConstraintDataT
 
class  DistanceErrorFunctionT
 
struct  EigenStrongType
 
struct  ErrorFunctionDerivativesT
 
struct  FbxCoordSystemInfo
 A struct containing the up, front vectors and coordinate system for FBX export. More...
 
struct  FileSaveOptions
 Unified options for saving files in both FBX and GLTF formats. More...
 
class  FiniteDifferenceSequenceErrorFunctionT
 Base class for error functions that penalize finite difference derivatives of joint positions across consecutive frames using a configurable stencil. More...
 
class  FixedAxisAngleErrorFunctionT
 Angle: compute the angle between the two axis using acosine of their dot product. More...
 
class  FixedAxisCosErrorFunctionT
 Cos: compute the dot product between the two axis - cosine of the angle between them. More...
 
struct  FixedAxisDataT
 Axis constraint data. More...
 
class  FixedAxisDiffErrorFunctionT
 Diff: compute the element wise differences between the two axis. More...
 
class  FullyDifferentiableDistanceErrorFunctionT
 
class  FullyDifferentiableMotionErrorFunctionT
 
class  FullyDifferentiableOrientationErrorFunctionT
 
class  FullyDifferentiablePosePriorErrorFunctionT
 
class  FullyDifferentiablePositionErrorFunctionT
 
class  FullyDifferentiableProjectionErrorFunctionT
 
class  FullyDifferentiableSkeletonErrorFunctionT
 
class  FullyDifferentiableStateErrorFunctionT
 
struct  GaussNewtonSolverBaseOptions
 Base options shared by all dense Gauss-Newton solver variants. More...
 
struct  GaussNewtonSolverOptions
 Extended options specific to the Gauss-Newton optimization algorithm. More...
 
struct  GaussNewtonSolverQROptions
 Gauss-Newton solver with QR decomposition specific options. More...
 
class  GaussNewtonSolverQRT
 
class  GaussNewtonSolverT
 Dense implementation of the Gauss-Newton optimization algorithm. More...
 
class  GeneralizedLossT
 Implementation of "A General and Adaptive Robust Loss Function" (https://arxiv.org/abs/1701.03077). More...
 
class  GltfBuilder
 Helper class to build a glb scene. More...
 
struct  GradientDescentSolverOptions
 Extended options for the Gradient Descent optimization algorithm. More...
 
class  GradientDescentSolverT
 First-order optimization algorithm that follows the negative gradient. More...
 
class  HeightErrorFunctionT
 Error function for character height constraints. More...
 
struct  InverseParameterTransformT
 
struct  IOOptions
 
struct  ispanstream
 istream that takes a span of const bytes as input. More...
 
class  JerkSequenceErrorFunctionT
 Error function that penalizes the jerk (third derivative) of joint positions across four consecutive frames using a standard finite difference stencil [1, -3, 3, -1]. More...
 
struct  JointParametersT
 
struct  JointStateT
 Represents the state of a joint with local and global transformations. More...
 
struct  JointT
 A simplified version of a Maya joint with pre-rotation only (no post-rotation). More...
 
struct  JointToJointDistanceConstraintT
 Constraint that enforces a distance relationship between two points attached to different joints. More...
 
class  JointToJointDistanceErrorFunctionT
 Error function that penalizes deviation from a target distance between two points attached to different joints. More...
 
struct  JointToJointPositionDataT
 Constraint data for joint-to-joint position error between two joints. More...
 
class  JointToJointPositionErrorFunctionT
 Error function that penalizes deviation from a target position expressed in a reference joint's coordinate frame. More...
 
union  LimitData
 
struct  LimitEllipsoid
 
class  LimitErrorFunctionT
 
struct  LimitHalfPlane
 Constraint: (p1, p2) ยท (normal) - offset >= 0. More...
 
struct  LimitLinear
 Linear relationship between parameters: p_0 = s * p_1 - o. More...
 
struct  LimitLinearJoint
 
struct  LimitMinMax
 
struct  LimitMinMaxJoint
 
struct  Locator
 Represents a point attached to a joint in a skeleton. More...
 
struct  LocatorState
 Tracks the current world positions of locators in a skeleton. More...
 
class  LowRankCovarianceMatrixT
 
struct  Marker
 Marker represents a motion capture marker that defines an active marker during motion capture. More...
 
struct  MarkerSequence
 MarkerSequence stores all the frames from a single capture sequence for one subject (motion capture actor). More...
 
struct  MeshStateT
 Represents the complete state of a model's mesh. More...
 
struct  MeshT
 A generic mesh representation with support for vertices, faces, lines, and texture coordinates. More...
 
struct  ModelOptions
 
class  ModelParametersErrorFunctionT
 
class  ModelParametersSequenceErrorFunctionT
 
struct  ModelParametersT
 
struct  MppcaT
 Mixture of Probabilistic Principal Component Analysis (MPPCA) Based on: http://www.miketipping.com/papers/met-mppca.pdf. More...
 
class  MultiposeSolverFunctionT
 
struct  MultiposeSolverOptions
 Multipose solver specific options. More...
 
class  MultiposeSolverT
 
struct  NormalDataT
 Normal constraint data: data needed to compute the point-to-plane distance for "data-to-template" in ICP. More...
 
class  NormalErrorFunctionT
 The NormalErrorFunction computes a "point-to-plane" (signed) distance from a target point to the plane defined by a local point and a local normal vector. More...
 
class  OnlineBandedHouseholderQR
 
class  OnlineBlockHouseholderQR
 
class  OnlineHouseholderQR
 
struct  OrientationConstraintStateT
 
struct  OrientationConstraintT
 
struct  OrientationDataT
 Constraint data on 3x3 rotation represented in quaternions. More...
 
class  OrientationErrorFunctionT
 The OrientationErrorFunction minimizes the F-norm of the element-wise difference of a 3x3 rotation matrix to a target rotation. More...
 
struct  ParameterLimit
 
struct  ParameterTransformT
 A parameter transform is an abstraction of the joint parameters that maps a model_parameter vector to a joint_parameter vector. More...
 
struct  PerFrameStateT
 
struct  PlaneDataT
 Point-on-plane or Point-in-half-plane constraint data. More...
 
class  PlaneErrorFunctionT
 The PlaneErrorFunction computes the point-on-plane error or point-in-half-plane error. More...
 
struct  PointTriangleVertexConstraintT
 
class  PointTriangleVertexErrorFunctionT
 Support constraining different parts of the mesh together by specifying that a source vertex should target a location on the mesh defined by a target triangle and its normal. More...
 
struct  PolygonData
 
struct  PoseConstraint
 
class  PosePriorErrorFunctionT
 
struct  PoseShape
 Computes shape deformations based on joint rotations. More...
 
class  PoseTransformSolverT
 Solver which can be reused to repeatedly apply the transformPose function listed above. More...
 
struct  PositionConstraintStateT
 
struct  PositionConstraintT
 
struct  PositionDataT
 3D position constraint data More...
 
class  PositionErrorFunctionT
 The PositionErrorFunction computes the 3D positional errors from a list of Constraints. More...
 
class  ProgressBar
 
struct  ProjectionConstraintDataT
 
class  ProjectionErrorFunctionT
 
class  Random
 A consolidated random number generator to provide convenient APIs wrapping around the random library of C++ standard library <random>. More...
 
struct  RefineConfig
 Configuration for refining an already tracked motion, eg. More...
 
class  ResizeableMatrix
 A matrix class that can be resized without reallocating memory when shrinking. More...
 
class  SequenceErrorFunctionT
 
class  SequenceSolverFunctionT
 
struct  SequenceSolverOptions
 Sequence solver specific options. More...
 
class  SequenceSolverT
 
class  SimdCollisionErrorFunctionT
 Represents an error function that penalizes self-intersections between collision geometries of the character. More...
 
class  SimdGeneralizedLossT
 SIMD version of the generalized loss function. More...
 
struct  SimdNormalConstraints
 
class  SimdNormalErrorFunction
 A highly optimized error function for "point-to-plane" (signed) distance errors. More...
 
struct  SimdPlaneConstraints
 
class  SimdPlaneErrorFunction
 A highly optimized error function for "point-on-plane" or "point-in-half-plane" errors. More...
 
struct  SimdPositionConstraints
 
class  SimdPositionErrorFunction
 A highly optimized error function for 3d position errors. More...
 
class  SkeletonErrorFunctionT
 
class  SkeletonSolverFunctionT
 
struct  SkeletonStateT
 Represents the complete state of a skeleton. More...
 
struct  SkeletonT
 The skeletal structure of a momentum Character. More...
 
struct  SkinnedLocator
 A skinned locator is a locator which can be attached to multiple bones. More...
 
struct  SkinnedLocatorConstraintT
 Constraint structure for skinned locator error function. More...
 
class  SkinnedLocatorErrorFunctionT
 Error function for skinned locator constraints. More...
 
struct  SkinnedLocatorTriangleConstraintT
 
class  SkinnedLocatorTriangleErrorFunctionT
 Support constraining a skinned locator to a location on the mesh defined by a target triangle and its normal. More...
 
class  SkinningWeightIteratorT
 
struct  SkinWeights
 Stores skinning weights and joint indices for character mesh deformation. More...
 
class  SolverFunctionT
 Abstract base class for optimization objective functions. More...
 
struct  SolverOptions
 Common options for numerical optimization solvers. More...
 
class  SolverT
 Base class for numerical optimization solvers. More...
 
struct  spanstreambuf
 Stream buffer based on a span. More...
 
struct  SparseGaussNewtonSolverOptions
 Extended options specific to the sparse Gauss-Newton optimization algorithm. More...
 
class  SparseGaussNewtonSolverT
 Sparse implementation of the Gauss-Newton optimization algorithm. More...
 
class  StateErrorFunctionT
 
class  StateSequenceErrorFunctionT
 Error function that penalizes the difference between the current skeleton state and the next skeleton state. More...
 
struct  StateSimilarity
 Measures of similarity between two skeleton states. More...
 
struct  SubsetGaussNewtonSolverOptions
 Extended options for the Subset Gauss-Newton optimization algorithm. More...
 
class  SubsetGaussNewtonSolverT
 Gauss-Newton solver that optimizes only a selected subset of parameters. More...
 
struct  TaperedCapsuleT
 Tapered capsule collision geometry for character collision detection. More...
 
struct  TrackingConfig
 Configuration for pose tracking given a calibrated body and locators. More...
 
struct  TransformT
 Lightweight transform with separate rotation, translation, and uniform scaling. More...
 
struct  TrustRegionQROptions
 Trust Region with QR decomposition specific options. More...
 
class  TrustRegionQRT
 
class  UnionErrorFunctionT
 
class  VelocityMagnitudeSequenceErrorFunctionT
 Error function that penalizes the deviation of per-joint velocity magnitude from a target speed. More...
 
struct  VertexConstraintT
 
class  VertexErrorFunctionT
 
struct  VertexProjectionConstraintT
 
class  VertexProjectionErrorFunctionT
 
class  VertexSequenceErrorFunctionT
 Error function that penalizes differences in vertex velocity between source and target motion. More...
 
struct  VertexVelocityConstraintT
 Constraint structure for vertex velocity. More...
 
struct  VertexVertexDistanceConstraintT
 Constraint for vertex-to-vertex distance errors. More...
 
class  VertexVertexDistanceErrorFunctionT
 Error function for vertex-to-vertex distance constraints. More...
 

Typedefs

using ProgressBar_p = ::std::shared_ptr< ProgressBar >
 
using ProgressBar_u = ::std::unique_ptr< ProgressBar >
 
using ProgressBar_w = ::std::weak_ptr< ProgressBar >
 
using ProgressBar_const_p = ::std::shared_ptr< const ProgressBar >
 
using ProgressBar_const_u = ::std::unique_ptr< const ProgressBar >
 
using ProgressBar_const_w = ::std::weak_ptr< const ProgressBar >
 
template<typename T >
using Packet = drjit::Packet< T, kSimdPacketSize >
 
using FloatP = Packet< float >
 
using DoubleP = Packet< double >
 
using IntP = Packet< int >
 
template<typename T , int Dim>
using VectorP = drjit::Array< Packet< T >, Dim >
 
template<typename T >
using Vector2P = VectorP< T, 2 >
 
template<typename T >
using Vector3P = VectorP< T, 3 >
 
using Vector2fP = Vector2P< float >
 
using Vector3fP = Vector3P< float >
 
using Vector2dP = Vector2P< double >
 
using Vector3dP = Vector3P< double >
 
using ByteP = Packet< uint8_t >
 Additional packet types for byte and unsigned integer data.
 
using UintP = Packet< uint32_t >
 
using Vector2iP = drjit::Array< IntP, 2 >
 Integer and byte vector types.
 
using Vector3iP = drjit::Array< IntP, 3 >
 
using Vector3bP = drjit::Array< ByteP, 3 >
 
template<typename T >
using Vector4P = VectorP< T, 4 >
 4D vector types.
 
using Vector4fP = Vector4P< float >
 
using Vector4dP = Vector4P< double >
 
template<typename T , int Dim>
using MatrixP = drjit::Matrix< Packet< T >, Dim >
 Matrix types for SIMD packets.
 
template<typename T >
using Matrix3P = MatrixP< T, 3 >
 
template<typename T >
using Matrix4P = MatrixP< T, 4 >
 
using Matrix3fP = Matrix3P< float >
 
using Matrix3dP = Matrix3P< double >
 
using Matrix4fP = Matrix4P< float >
 
using Matrix4dP = Matrix4P< double >
 
using Mesh = MeshT< float >
 
using Meshd = MeshT< double >
 
using Mesh_p = ::std::shared_ptr< Mesh >
 
using Mesh_u = ::std::unique_ptr< Mesh >
 
using Mesh_w = ::std::weak_ptr< Mesh >
 
using Mesh_const_p = ::std::shared_ptr< const Mesh >
 
using Mesh_const_u = ::std::unique_ptr< const Mesh >
 
using Mesh_const_w = ::std::weak_ptr< const Mesh >
 
using Meshd_p = ::std::shared_ptr< Meshd >
 
using Meshd_u = ::std::unique_ptr< Meshd >
 
using Meshd_w = ::std::weak_ptr< Meshd >
 
using Meshd_const_p = ::std::shared_ptr< const Meshd >
 
using Meshd_const_u = ::std::unique_ptr< const Meshd >
 
using Meshd_const_w = ::std::weak_ptr< const Meshd >
 
using Mppca = MppcaT< float >
 
using Mppcad = MppcaT< double >
 
using Mppca_p = ::std::shared_ptr< Mppca >
 
using Mppca_u = ::std::unique_ptr< Mppca >
 
using Mppca_w = ::std::weak_ptr< Mppca >
 
using Mppca_const_p = ::std::shared_ptr< const Mppca >
 
using Mppca_const_u = ::std::unique_ptr< const Mppca >
 
using Mppca_const_w = ::std::weak_ptr< const Mppca >
 
using Mppcad_p = ::std::shared_ptr< Mppcad >
 
using Mppcad_u = ::std::unique_ptr< Mppcad >
 
using Mppcad_w = ::std::weak_ptr< Mppcad >
 
using Mppcad_const_p = ::std::shared_ptr< const Mppcad >
 
using Mppcad_const_u = ::std::unique_ptr< const Mppcad >
 
using Mppcad_const_w = ::std::weak_ptr< const Mppcad >
 
using Transform = TransformT< float >
 
using Transformd = TransformT< double >
 
using Transform_p = ::std::shared_ptr< Transform >
 
using Transform_u = ::std::unique_ptr< Transform >
 
using Transform_w = ::std::weak_ptr< Transform >
 
using Transform_const_p = ::std::shared_ptr< const Transform >
 
using Transform_const_u = ::std::unique_ptr< const Transform >
 
using Transform_const_w = ::std::weak_ptr< const Transform >
 
using Transformd_p = ::std::shared_ptr< Transformd >
 
using Transformd_u = ::std::unique_ptr< Transformd >
 
using Transformd_w = ::std::weak_ptr< Transformd >
 
using Transformd_const_p = ::std::shared_ptr< const Transformd >
 
using Transformd_const_u = ::std::unique_ptr< const Transformd >
 
using Transformd_const_w = ::std::weak_ptr< const Transformd >
 
using LowRankCovarianceMatrix = LowRankCovarianceMatrixT< float >
 
using LowRankCovarianceMatrixd = LowRankCovarianceMatrixT< double >
 
using LowRankCovarianceMatrix_p = ::std::shared_ptr< LowRankCovarianceMatrix >
 
using LowRankCovarianceMatrix_u = ::std::unique_ptr< LowRankCovarianceMatrix >
 
using LowRankCovarianceMatrix_w = ::std::weak_ptr< LowRankCovarianceMatrix >
 
using LowRankCovarianceMatrix_const_p = ::std::shared_ptr< const LowRankCovarianceMatrix >
 
using LowRankCovarianceMatrix_const_u = ::std::unique_ptr< const LowRankCovarianceMatrix >
 
using LowRankCovarianceMatrix_const_w = ::std::weak_ptr< const LowRankCovarianceMatrix >
 
using LowRankCovarianceMatrixd_p = ::std::shared_ptr< LowRankCovarianceMatrixd >
 
using LowRankCovarianceMatrixd_u = ::std::unique_ptr< LowRankCovarianceMatrixd >
 
using LowRankCovarianceMatrixd_w = ::std::weak_ptr< LowRankCovarianceMatrixd >
 
using LowRankCovarianceMatrixd_const_p = ::std::shared_ptr< const LowRankCovarianceMatrixd >
 
using LowRankCovarianceMatrixd_const_u = ::std::unique_ptr< const LowRankCovarianceMatrixd >
 
using LowRankCovarianceMatrixd_const_w = ::std::weak_ptr< const LowRankCovarianceMatrixd >
 
using GeneralizedLoss = GeneralizedLossT< float >
 
using GeneralizedLossd = GeneralizedLossT< double >
 
using GeneralizedLoss_p = ::std::shared_ptr< GeneralizedLoss >
 
using GeneralizedLoss_u = ::std::unique_ptr< GeneralizedLoss >
 
using GeneralizedLoss_w = ::std::weak_ptr< GeneralizedLoss >
 
using GeneralizedLoss_const_p = ::std::shared_ptr< const GeneralizedLoss >
 
using GeneralizedLoss_const_u = ::std::unique_ptr< const GeneralizedLoss >
 
using GeneralizedLoss_const_w = ::std::weak_ptr< const GeneralizedLoss >
 
using GeneralizedLossd_p = ::std::shared_ptr< GeneralizedLossd >
 
using GeneralizedLossd_u = ::std::unique_ptr< GeneralizedLossd >
 
using GeneralizedLossd_w = ::std::weak_ptr< GeneralizedLossd >
 
using GeneralizedLossd_const_p = ::std::shared_ptr< const GeneralizedLossd >
 
using GeneralizedLossd_const_u = ::std::unique_ptr< const GeneralizedLossd >
 
using GeneralizedLossd_const_w = ::std::weak_ptr< const GeneralizedLossd >
 
using SimdGeneralizedLoss = SimdGeneralizedLossT< float >
 
using SimdGeneralizedLossd = SimdGeneralizedLossT< double >
 
using SimdGeneralizedLoss_p = ::std::shared_ptr< SimdGeneralizedLoss >
 
using SimdGeneralizedLoss_u = ::std::unique_ptr< SimdGeneralizedLoss >
 
using SimdGeneralizedLoss_w = ::std::weak_ptr< SimdGeneralizedLoss >
 
using SimdGeneralizedLoss_const_p = ::std::shared_ptr< const SimdGeneralizedLoss >
 
using SimdGeneralizedLoss_const_u = ::std::unique_ptr< const SimdGeneralizedLoss >
 
using SimdGeneralizedLoss_const_w = ::std::weak_ptr< const SimdGeneralizedLoss >
 
using SimdGeneralizedLossd_p = ::std::shared_ptr< SimdGeneralizedLossd >
 
using SimdGeneralizedLossd_u = ::std::unique_ptr< SimdGeneralizedLossd >
 
using SimdGeneralizedLossd_w = ::std::weak_ptr< SimdGeneralizedLossd >
 
using SimdGeneralizedLossd_const_p = ::std::shared_ptr< const SimdGeneralizedLossd >
 
using SimdGeneralizedLossd_const_u = ::std::unique_ptr< const SimdGeneralizedLossd >
 
using SimdGeneralizedLossd_const_w = ::std::weak_ptr< const SimdGeneralizedLossd >
 
template<typename T >
using TransformListT = std::vector< TransformT< T > >
 
using TransformList = TransformListT< float >
 
template<class T >
using Map = Eigen::Map< T >
 
template<class T >
using Ref = Eigen::Ref< T >
 
template<typename Scalar , int Dim>
using Line = Eigen::ParametrizedLine< Scalar, Dim >
 
template<typename Scalar , int Dim>
using Plane = Eigen::Hyperplane< Scalar, Dim >
 
template<typename Scalar , int Dim>
using Box = Eigen::AlignedBox< Scalar, Dim >
 
template<int Dim>
using Boxf = Eigen::AlignedBox< float, Dim >
 
template<int Dim>
using Boxd = Eigen::AlignedBox< double, Dim >
 
template<int Dim>
using Boxi = Eigen::AlignedBox< std::int32_t, Dim >
 
template<typename T >
using Box2 = Eigen::AlignedBox< T, 2 >
 
template<typename T >
using Box3 = Eigen::AlignedBox< T, 3 >
 
using Box2f = Box2< float >
 
using Box3f = Box3< float >
 
using Box2d = Box2< double >
 
using Box3d = Box3< double >
 
using Box2i = Box2< std::int32_t >
 
using Box3i = Box3< std::int32_t >
 
template<typename T >
using MatrixX = Eigen::Matrix< T, Dynamic, Dynamic >
 
using MatrixXf = MatrixX< float >
 
using MatrixXd = MatrixX< double >
 
using MatrixXb = MatrixX< std::uint8_t >
 
using MatrixXs = MatrixX< std::uint16_t >
 
using MatrixXu = MatrixX< std::uint32_t >
 
using MatrixXi = MatrixX< std::int32_t >
 
template<typename T >
using Matrix0 = Eigen::Matrix< T, 0, 0 >
 
template<typename T >
using Matrix1 = Eigen::Matrix< T, 1, 1 >
 
template<typename T >
using Matrix2 = Eigen::Matrix< T, 2, 2 >
 
template<typename T >
using Matrix3 = Eigen::Matrix< T, 3, 3 >
 
template<typename T >
using Matrix4 = Eigen::Matrix< T, 4, 4 >
 
template<typename T >
using Matrix5 = Eigen::Matrix< T, 5, 5 >
 
template<typename T >
using Matrix6 = Eigen::Matrix< T, 6, 6 >
 
using Matrix0f = Matrix0< float >
 
using Matrix1f = Matrix1< float >
 
using Matrix2f = Matrix2< float >
 
using Matrix3f = Matrix3< float >
 
using Matrix4f = Matrix4< float >
 
using Matrix5f = Matrix5< float >
 
using Matrix6f = Matrix6< float >
 
using Matrix0d = Matrix0< double >
 
using Matrix1d = Matrix1< double >
 
using Matrix2d = Matrix2< double >
 
using Matrix3d = Matrix3< double >
 
using Matrix4d = Matrix4< double >
 
using Matrix5d = Matrix5< double >
 
using Matrix6d = Matrix6< double >
 
using Matrix0b = Matrix0< std::uint8_t >
 
using Matrix1b = Matrix1< std::uint8_t >
 
using Matrix2b = Matrix2< std::uint8_t >
 
using Matrix3b = Matrix3< std::uint8_t >
 
using Matrix4b = Matrix4< std::uint8_t >
 
using Matrix5b = Matrix5< std::uint8_t >
 
using Matrix6b = Matrix6< std::uint8_t >
 
using Matrix0s = Matrix0< std::uint16_t >
 
using Matrix1s = Matrix1< std::uint16_t >
 
using Matrix2s = Matrix2< std::uint16_t >
 
using Matrix3s = Matrix3< std::uint16_t >
 
using Matrix4s = Matrix4< std::uint16_t >
 
using Matrix5s = Matrix5< std::uint16_t >
 
using Matrix6s = Matrix6< std::uint16_t >
 
using Matrix0u = Matrix0< std::uint32_t >
 
using Matrix1u = Matrix1< std::uint32_t >
 
using Matrix2u = Matrix2< std::uint32_t >
 
using Matrix3u = Matrix3< std::uint32_t >
 
using Matrix4u = Matrix4< std::uint32_t >
 
using Matrix5u = Matrix5< std::uint32_t >
 
using Matrix6u = Matrix6< std::uint32_t >
 
using Matrix0i = Matrix0< std::int32_t >
 
using Matrix1i = Matrix1< std::int32_t >
 
using Matrix2i = Matrix2< std::int32_t >
 
using Matrix3i = Matrix3< std::int32_t >
 
using Matrix4i = Matrix4< std::int32_t >
 
using Matrix5i = Matrix5< std::int32_t >
 
using Matrix6i = Matrix6< std::int32_t >
 
template<typename T >
using Matrix3X = Eigen::Matrix< T, 3, Dynamic >
 
using Matrix3Xf = Matrix3X< float >
 
using Matrix3Xd = Matrix3X< double >
 
using Matrix3Xb = Matrix3X< std::uint8_t >
 
using Matrix3Xs = Matrix3X< std::uint16_t >
 
using Matrix3Xu = Matrix3X< std::uint32_t >
 
using Matrix3Xi = Matrix3X< std::int32_t >
 
template<typename T >
using MatrixX3 = Eigen::Matrix< T, Dynamic, 3 >
 
using MatrixX3f = MatrixX3< float >
 
using MatrixX3d = MatrixX3< double >
 
using MatrixX3b = MatrixX3< std::uint8_t >
 
using MatrixX3s = MatrixX3< std::uint16_t >
 
using MatrixX3u = MatrixX3< std::uint32_t >
 
using MatrixX3i = MatrixX3< std::int32_t >
 
template<typename T , int N, int M = N>
using RowMatrix = Eigen::Matrix< T, N, M, Eigen::RowMajor >
 
template<typename T >
using RowMatrixX = RowMatrix< T, Dynamic >
 
template<typename T >
using SparseMatrix = Eigen::SparseMatrix< T >
 
using SparseMatrixf = SparseMatrix< float >
 
using SparseMatrixd = SparseMatrix< double >
 
using SparseMatrixb = SparseMatrix< std::uint8_t >
 
using SparseMatrixs = SparseMatrix< std::uint16_t >
 
using SparseMatrixu = SparseMatrix< std::uint32_t >
 
using SparseMatrixi = SparseMatrix< std::int32_t >
 
template<typename T >
using SparseRowMatrix = Eigen::SparseMatrix< T, Eigen::RowMajor >
 
using SparseRowMatrixf = SparseRowMatrix< float >
 
using SparseRowMatrixd = SparseRowMatrix< double >
 
using SparseRowMatrixb = SparseRowMatrix< std::uint8_t >
 
using SparseRowMatrixs = SparseRowMatrix< std::uint16_t >
 
using SparseRowMatrixu = SparseRowMatrix< std::uint32_t >
 
using SparseRowMatrixi = SparseRowMatrix< std::int32_t >
 
template<typename T , int Dim, int Options = 0>
using Vector = Eigen::Matrix< T, Dim, 1, Options >
 
template<typename T >
using VectorX = Vector< T, Dynamic >
 
using VectorXf = VectorX< float >
 
using VectorXd = VectorX< double >
 
using VectorXb = VectorX< std::uint8_t >
 
using VectorXs = VectorX< std::uint16_t >
 
using VectorXu = VectorX< std::uint32_t >
 
using VectorXi = VectorX< std::int32_t >
 
template<int Dim>
using Vectorf = Vector< float, Dim >
 
template<int Dim>
using Vectord = Vector< double, Dim >
 
template<int Dim>
using Vectorb = Vector< std::uint8_t, Dim >
 
template<int Dim>
using Vectors = Vector< std::uint16_t, Dim >
 
template<int Dim>
using Vectoru = Vector< std::uint32_t, Dim >
 
template<int Dim>
using Vectori = Vector< std::int32_t, Dim >
 
template<typename T >
using Vector0 = Vector< T, 0 >
 
template<typename T >
using Vector1 = Vector< T, 1 >
 
template<typename T >
using Vector2 = Vector< T, 2 >
 
template<typename T >
using Vector3 = Vector< T, 3 >
 
template<typename T >
using Vector4 = Vector< T, 4 >
 
template<typename T >
using Vector5 = Vector< T, 5 >
 
template<typename T >
using Vector6 = Vector< T, 6 >
 
template<typename T >
using Vector7 = Vector< T, 7 >
 
template<typename T >
using Vector8 = Vector< T, 8 >
 
using Vector0f = Vector0< float >
 
using Vector1f = Vector1< float >
 
using Vector2f = Vector2< float >
 
using Vector3f = Vector3< float >
 
using Vector4f = Vector4< float >
 
using Vector5f = Vector5< float >
 
using Vector6f = Vector6< float >
 
using Vector7f = Vector7< float >
 
using Vector8f = Vector8< float >
 
using Vector0d = Vector0< double >
 
using Vector1d = Vector1< double >
 
using Vector2d = Vector2< double >
 
using Vector3d = Vector3< double >
 
using Vector4d = Vector4< double >
 
using Vector5d = Vector5< double >
 
using Vector6d = Vector6< double >
 
using Vector0b = Vector0< std::uint8_t >
 
using Vector1b = Vector1< std::uint8_t >
 
using Vector2b = Vector2< std::uint8_t >
 
using Vector3b = Vector3< std::uint8_t >
 
using Vector4b = Vector4< std::uint8_t >
 
using Vector5b = Vector5< std::uint8_t >
 
using Vector6b = Vector6< std::uint8_t >
 
using Vector0s = Vector0< std::uint16_t >
 
using Vector1s = Vector1< std::uint16_t >
 
using Vector2s = Vector2< std::uint16_t >
 
using Vector3s = Vector3< std::uint16_t >
 
using Vector4s = Vector4< std::uint16_t >
 
using Vector5s = Vector5< std::uint16_t >
 
using Vector6s = Vector6< std::uint16_t >
 
using Vector0u = Vector0< std::uint32_t >
 
using Vector1u = Vector1< std::uint32_t >
 
using Vector2u = Vector2< std::uint32_t >
 
using Vector3u = Vector3< std::uint32_t >
 
using Vector4u = Vector4< std::uint32_t >
 
using Vector5u = Vector5< std::uint32_t >
 
using Vector6u = Vector6< std::uint32_t >
 
using Vector0i = Vector0< std::int32_t >
 
using Vector1i = Vector1< std::int32_t >
 
using Vector2i = Vector2< std::int32_t >
 
using Vector3i = Vector3< std::int32_t >
 
using Vector4i = Vector4< std::int32_t >
 
using Vector5i = Vector5< std::int32_t >
 
using Vector6i = Vector6< std::int32_t >
 
template<typename T , int Dim>
using RowVector = Eigen::Matrix< T, 1, Dim >
 
template<typename T >
using RowVectorX = RowVector< T, Dynamic >
 
using RowVectorXf = RowVectorX< float >
 
using RowVectorXd = RowVectorX< double >
 
using RowVectorXb = RowVectorX< std::uint8_t >
 
using RowVectorXs = RowVectorX< std::uint16_t >
 
using RowVectorXu = RowVectorX< std::uint32_t >
 
using RowVectorXi = RowVectorX< std::int32_t >
 
template<typename T >
using RowVector0 = RowVector< T, 0 >
 
template<typename T >
using RowVector1 = RowVector< T, 1 >
 
template<typename T >
using RowVector2 = RowVector< T, 2 >
 
template<typename T >
using RowVector3 = RowVector< T, 3 >
 
template<typename T >
using RowVector4 = RowVector< T, 4 >
 
template<typename T >
using RowVector5 = RowVector< T, 5 >
 
template<typename T >
using RowVector6 = RowVector< T, 6 >
 
using RowVector0f = RowVector0< float >
 
using RowVector1f = RowVector1< float >
 
using RowVector2f = RowVector2< float >
 
using RowVector3f = RowVector3< float >
 
using RowVector4f = RowVector4< float >
 
using RowVector5f = RowVector5< float >
 
using RowVector6f = RowVector6< float >
 
using RowVector0d = RowVector0< double >
 
using RowVector1d = RowVector1< double >
 
using RowVector2d = RowVector2< double >
 
using RowVector3d = RowVector3< double >
 
using RowVector4d = RowVector4< double >
 
using RowVector5d = RowVector5< double >
 
using RowVector6d = RowVector6< double >
 
using RowVector0b = RowVector0< std::uint8_t >
 
using RowVector1b = RowVector1< std::uint8_t >
 
using RowVector2b = RowVector2< std::uint8_t >
 
using RowVector3b = RowVector3< std::uint8_t >
 
using RowVector4b = RowVector4< std::uint8_t >
 
using RowVector5b = RowVector5< std::uint8_t >
 
using RowVector6b = RowVector6< std::uint8_t >
 
using RowVector0s = RowVector0< std::uint16_t >
 
using RowVector1s = RowVector1< std::uint16_t >
 
using RowVector2s = RowVector2< std::uint16_t >
 
using RowVector3s = RowVector3< std::uint16_t >
 
using RowVector4s = RowVector4< std::uint16_t >
 
using RowVector5s = RowVector5< std::uint16_t >
 
using RowVector6s = RowVector6< std::uint16_t >
 
using RowVector0u = RowVector0< std::uint32_t >
 
using RowVector1u = RowVector1< std::uint32_t >
 
using RowVector2u = RowVector2< std::uint32_t >
 
using RowVector3u = RowVector3< std::uint32_t >
 
using RowVector4u = RowVector4< std::uint32_t >
 
using RowVector5u = RowVector5< std::uint32_t >
 
using RowVector6u = RowVector6< std::uint32_t >
 
using RowVector0i = RowVector0< std::int32_t >
 
using RowVector1i = RowVector1< std::int32_t >
 
using RowVector2i = RowVector2< std::int32_t >
 
using RowVector3i = RowVector3< std::int32_t >
 
using RowVector4i = RowVector4< std::int32_t >
 
using RowVector5i = RowVector5< std::int32_t >
 
using RowVector6i = RowVector6< std::int32_t >
 
template<typename T >
using AngleAxis = Eigen::AngleAxis< T >
 
using AngleAxisf = AngleAxis< float >
 
using AngleAxisd = AngleAxis< double >
 
template<typename T >
using Quaternion = Eigen::Quaternion< T >
 
using Quaternionf = Quaternion< float >
 
using Quaterniond = Quaternion< double >
 
template<typename T >
using Translation3 = Eigen::Translation< T, 3 >
 
using Translation3f = Translation3< float >
 
using Translation3d = Translation3< double >
 
template<typename T >
using Isometry3 = Eigen::Transform< T, 3, Eigen::Isometry >
 
using Isometry3f = Isometry3< float >
 
using Isometry3d = Isometry3< double >
 
template<typename T >
using Affine3 = Eigen::Transform< T, 3, Eigen::Affine >
 
using Affine3f = Affine3< float >
 
using Affine3d = Affine3< double >
 
using TransformationList = std::vector< Affine3f >
 
template<typename T >
using TransformationListT = std::vector< Affine3< T > >
 
using VertexArray = Matrix3Xf
 
using NormalArray = Matrix3Xf
 
using TriangleArray = Matrix3Xi
 
using ColorArray = Matrix3Xb
 
using ParameterSet = std::bitset< kMaxModelParams >
 
using SolverOptions_p = ::std::shared_ptr< SolverOptions >
 
using SolverOptions_u = ::std::unique_ptr< SolverOptions >
 
using SolverOptions_w = ::std::weak_ptr< SolverOptions >
 
using SolverOptions_const_p = ::std::shared_ptr< const SolverOptions >
 
using SolverOptions_const_u = ::std::unique_ptr< const SolverOptions >
 
using SolverOptions_const_w = ::std::weak_ptr< const SolverOptions >
 
using GaussNewtonSolverOptions_p = ::std::shared_ptr< GaussNewtonSolverOptions >
 
using GaussNewtonSolverOptions_u = ::std::unique_ptr< GaussNewtonSolverOptions >
 
using GaussNewtonSolverOptions_w = ::std::weak_ptr< GaussNewtonSolverOptions >
 
using GaussNewtonSolverOptions_const_p = ::std::shared_ptr< const GaussNewtonSolverOptions >
 
using GaussNewtonSolverOptions_const_u = ::std::unique_ptr< const GaussNewtonSolverOptions >
 
using GaussNewtonSolverOptions_const_w = ::std::weak_ptr< const GaussNewtonSolverOptions >
 
using SparseGaussNewtonSolverOptions_p = ::std::shared_ptr< SparseGaussNewtonSolverOptions >
 
using SparseGaussNewtonSolverOptions_u = ::std::unique_ptr< SparseGaussNewtonSolverOptions >
 
using SparseGaussNewtonSolverOptions_w = ::std::weak_ptr< SparseGaussNewtonSolverOptions >
 
using SparseGaussNewtonSolverOptions_const_p = ::std::shared_ptr< const SparseGaussNewtonSolverOptions >
 
using SparseGaussNewtonSolverOptions_const_u = ::std::unique_ptr< const SparseGaussNewtonSolverOptions >
 
using SparseGaussNewtonSolverOptions_const_w = ::std::weak_ptr< const SparseGaussNewtonSolverOptions >
 
using Solver = SolverT< float >
 
using Solverd = SolverT< double >
 
using Solver_p = ::std::shared_ptr< Solver >
 
using Solver_u = ::std::unique_ptr< Solver >
 
using Solver_w = ::std::weak_ptr< Solver >
 
using Solver_const_p = ::std::shared_ptr< const Solver >
 
using Solver_const_u = ::std::unique_ptr< const Solver >
 
using Solver_const_w = ::std::weak_ptr< const Solver >
 
using Solverd_p = ::std::shared_ptr< Solverd >
 
using Solverd_u = ::std::unique_ptr< Solverd >
 
using Solverd_w = ::std::weak_ptr< Solverd >
 
using Solverd_const_p = ::std::shared_ptr< const Solverd >
 
using Solverd_const_u = ::std::unique_ptr< const Solverd >
 
using Solverd_const_w = ::std::weak_ptr< const Solverd >
 
using SolverFunction = SolverFunctionT< float >
 
using SolverFunctiond = SolverFunctionT< double >
 
using SolverFunction_p = ::std::shared_ptr< SolverFunction >
 
using SolverFunction_u = ::std::unique_ptr< SolverFunction >
 
using SolverFunction_w = ::std::weak_ptr< SolverFunction >
 
using SolverFunction_const_p = ::std::shared_ptr< const SolverFunction >
 
using SolverFunction_const_u = ::std::unique_ptr< const SolverFunction >
 
using SolverFunction_const_w = ::std::weak_ptr< const SolverFunction >
 
using SolverFunctiond_p = ::std::shared_ptr< SolverFunctiond >
 
using SolverFunctiond_u = ::std::unique_ptr< SolverFunctiond >
 
using SolverFunctiond_w = ::std::weak_ptr< SolverFunctiond >
 
using SolverFunctiond_const_p = ::std::shared_ptr< const SolverFunctiond >
 
using SolverFunctiond_const_u = ::std::unique_ptr< const SolverFunctiond >
 
using SolverFunctiond_const_w = ::std::weak_ptr< const SolverFunctiond >
 
using GaussNewtonSolver = GaussNewtonSolverT< float >
 
using GaussNewtonSolverd = GaussNewtonSolverT< double >
 
using GaussNewtonSolver_p = ::std::shared_ptr< GaussNewtonSolver >
 
using GaussNewtonSolver_u = ::std::unique_ptr< GaussNewtonSolver >
 
using GaussNewtonSolver_w = ::std::weak_ptr< GaussNewtonSolver >
 
using GaussNewtonSolver_const_p = ::std::shared_ptr< const GaussNewtonSolver >
 
using GaussNewtonSolver_const_u = ::std::unique_ptr< const GaussNewtonSolver >
 
using GaussNewtonSolver_const_w = ::std::weak_ptr< const GaussNewtonSolver >
 
using GaussNewtonSolverd_p = ::std::shared_ptr< GaussNewtonSolverd >
 
using GaussNewtonSolverd_u = ::std::unique_ptr< GaussNewtonSolverd >
 
using GaussNewtonSolverd_w = ::std::weak_ptr< GaussNewtonSolverd >
 
using GaussNewtonSolverd_const_p = ::std::shared_ptr< const GaussNewtonSolverd >
 
using GaussNewtonSolverd_const_u = ::std::unique_ptr< const GaussNewtonSolverd >
 
using GaussNewtonSolverd_const_w = ::std::weak_ptr< const GaussNewtonSolverd >
 
using SparseGaussNewtonSolver = SparseGaussNewtonSolverT< float >
 
using SparseGaussNewtonSolverd = SparseGaussNewtonSolverT< double >
 
using SparseGaussNewtonSolver_p = ::std::shared_ptr< SparseGaussNewtonSolver >
 
using SparseGaussNewtonSolver_u = ::std::unique_ptr< SparseGaussNewtonSolver >
 
using SparseGaussNewtonSolver_w = ::std::weak_ptr< SparseGaussNewtonSolver >
 
using SparseGaussNewtonSolver_const_p = ::std::shared_ptr< const SparseGaussNewtonSolver >
 
using SparseGaussNewtonSolver_const_u = ::std::unique_ptr< const SparseGaussNewtonSolver >
 
using SparseGaussNewtonSolver_const_w = ::std::weak_ptr< const SparseGaussNewtonSolver >
 
using SparseGaussNewtonSolverd_p = ::std::shared_ptr< SparseGaussNewtonSolverd >
 
using SparseGaussNewtonSolverd_u = ::std::unique_ptr< SparseGaussNewtonSolverd >
 
using SparseGaussNewtonSolverd_w = ::std::weak_ptr< SparseGaussNewtonSolverd >
 
using SparseGaussNewtonSolverd_const_p = ::std::shared_ptr< const SparseGaussNewtonSolverd >
 
using SparseGaussNewtonSolverd_const_u = ::std::unique_ptr< const SparseGaussNewtonSolverd >
 
using SparseGaussNewtonSolverd_const_w = ::std::weak_ptr< const SparseGaussNewtonSolverd >
 
using GradientDescentSolver = GradientDescentSolverT< float >
 
using GradientDescentSolverd = GradientDescentSolverT< double >
 
using GradientDescentSolver_p = ::std::shared_ptr< GradientDescentSolver >
 
using GradientDescentSolver_u = ::std::unique_ptr< GradientDescentSolver >
 
using GradientDescentSolver_w = ::std::weak_ptr< GradientDescentSolver >
 
using GradientDescentSolver_const_p = ::std::shared_ptr< const GradientDescentSolver >
 
using GradientDescentSolver_const_u = ::std::unique_ptr< const GradientDescentSolver >
 
using GradientDescentSolver_const_w = ::std::weak_ptr< const GradientDescentSolver >
 
using GradientDescentSolverd_p = ::std::shared_ptr< GradientDescentSolverd >
 
using GradientDescentSolverd_u = ::std::unique_ptr< GradientDescentSolverd >
 
using GradientDescentSolverd_w = ::std::weak_ptr< GradientDescentSolverd >
 
using GradientDescentSolverd_const_p = ::std::shared_ptr< const GradientDescentSolverd >
 
using GradientDescentSolverd_const_u = ::std::unique_ptr< const GradientDescentSolverd >
 
using GradientDescentSolverd_const_w = ::std::weak_ptr< const GradientDescentSolverd >
 
using SubsetGaussNewtonSolver = SubsetGaussNewtonSolverT< float >
 
using SubsetGaussNewtonSolverd = SubsetGaussNewtonSolverT< double >
 
using SubsetGaussNewtonSolver_p = ::std::shared_ptr< SubsetGaussNewtonSolver >
 
using SubsetGaussNewtonSolver_u = ::std::unique_ptr< SubsetGaussNewtonSolver >
 
using SubsetGaussNewtonSolver_w = ::std::weak_ptr< SubsetGaussNewtonSolver >
 
using SubsetGaussNewtonSolver_const_p = ::std::shared_ptr< const SubsetGaussNewtonSolver >
 
using SubsetGaussNewtonSolver_const_u = ::std::unique_ptr< const SubsetGaussNewtonSolver >
 
using SubsetGaussNewtonSolver_const_w = ::std::weak_ptr< const SubsetGaussNewtonSolver >
 
using SubsetGaussNewtonSolverd_p = ::std::shared_ptr< SubsetGaussNewtonSolverd >
 
using SubsetGaussNewtonSolverd_u = ::std::unique_ptr< SubsetGaussNewtonSolverd >
 
using SubsetGaussNewtonSolverd_w = ::std::weak_ptr< SubsetGaussNewtonSolverd >
 
using SubsetGaussNewtonSolverd_const_p = ::std::shared_ptr< const SubsetGaussNewtonSolverd >
 
using SubsetGaussNewtonSolverd_const_u = ::std::unique_ptr< const SubsetGaussNewtonSolverd >
 
using SubsetGaussNewtonSolverd_const_w = ::std::weak_ptr< const SubsetGaussNewtonSolverd >
 
template<typename S >
using CollisionGeometryT = std::vector< TaperedCapsuleT< S > >
 Collection of tapered capsules representing a character's collision geometry.
 
using CollisionGeometry = CollisionGeometryT< float >
 
using CollisionGeometryd = CollisionGeometryT< double >
 
using BlendShape_p = ::std::shared_ptr< BlendShape >
 
using BlendShape_u = ::std::unique_ptr< BlendShape >
 
using BlendShape_w = ::std::weak_ptr< BlendShape >
 
using BlendShape_const_p = ::std::shared_ptr< const BlendShape >
 
using BlendShape_const_u = ::std::unique_ptr< const BlendShape >
 
using BlendShape_const_w = ::std::weak_ptr< const BlendShape >
 
using BlendShapeBase_p = ::std::shared_ptr< BlendShapeBase >
 
using BlendShapeBase_u = ::std::unique_ptr< BlendShapeBase >
 
using BlendShapeBase_w = ::std::weak_ptr< BlendShapeBase >
 
using BlendShapeBase_const_p = ::std::shared_ptr< const BlendShapeBase >
 
using BlendShapeBase_const_u = ::std::unique_ptr< const BlendShapeBase >
 
using BlendShapeBase_const_w = ::std::weak_ptr< const BlendShapeBase >
 
using Locator_p = ::std::shared_ptr< Locator >
 
using Locator_u = ::std::unique_ptr< Locator >
 
using Locator_w = ::std::weak_ptr< Locator >
 
using Locator_const_p = ::std::shared_ptr< const Locator >
 
using Locator_const_u = ::std::unique_ptr< const Locator >
 
using Locator_const_w = ::std::weak_ptr< const Locator >
 
using PoseShape_p = ::std::shared_ptr< PoseShape >
 
using PoseShape_u = ::std::unique_ptr< PoseShape >
 
using PoseShape_w = ::std::weak_ptr< PoseShape >
 
using PoseShape_const_p = ::std::shared_ptr< const PoseShape >
 
using PoseShape_const_u = ::std::unique_ptr< const PoseShape >
 
using PoseShape_const_w = ::std::weak_ptr< const PoseShape >
 
using SkinWeights_p = ::std::shared_ptr< SkinWeights >
 
using SkinWeights_u = ::std::unique_ptr< SkinWeights >
 
using SkinWeights_w = ::std::weak_ptr< SkinWeights >
 
using SkinWeights_const_p = ::std::shared_ptr< const SkinWeights >
 
using SkinWeights_const_u = ::std::unique_ptr< const SkinWeights >
 
using SkinWeights_const_w = ::std::weak_ptr< const SkinWeights >
 
using SkinnedLocator_p = ::std::shared_ptr< SkinnedLocator >
 
using SkinnedLocator_u = ::std::unique_ptr< SkinnedLocator >
 
using SkinnedLocator_w = ::std::weak_ptr< SkinnedLocator >
 
using SkinnedLocator_const_p = ::std::shared_ptr< const SkinnedLocator >
 
using SkinnedLocator_const_u = ::std::unique_ptr< const SkinnedLocator >
 
using SkinnedLocator_const_w = ::std::weak_ptr< const SkinnedLocator >
 
using Character = CharacterT< float >
 
using Characterd = CharacterT< double >
 
using Character_p = ::std::shared_ptr< Character >
 
using Character_u = ::std::unique_ptr< Character >
 
using Character_w = ::std::weak_ptr< Character >
 
using Character_const_p = ::std::shared_ptr< const Character >
 
using Character_const_u = ::std::unique_ptr< const Character >
 
using Character_const_w = ::std::weak_ptr< const Character >
 
using Characterd_p = ::std::shared_ptr< Characterd >
 
using Characterd_u = ::std::unique_ptr< Characterd >
 
using Characterd_w = ::std::weak_ptr< Characterd >
 
using Characterd_const_p = ::std::shared_ptr< const Characterd >
 
using Characterd_const_u = ::std::unique_ptr< const Characterd >
 
using Characterd_const_w = ::std::weak_ptr< const Characterd >
 
using CharacterState = CharacterStateT< float >
 
using CharacterStated = CharacterStateT< double >
 
using CharacterState_p = ::std::shared_ptr< CharacterState >
 
using CharacterState_u = ::std::unique_ptr< CharacterState >
 
using CharacterState_w = ::std::weak_ptr< CharacterState >
 
using CharacterState_const_p = ::std::shared_ptr< const CharacterState >
 
using CharacterState_const_u = ::std::unique_ptr< const CharacterState >
 
using CharacterState_const_w = ::std::weak_ptr< const CharacterState >
 
using CharacterStated_p = ::std::shared_ptr< CharacterStated >
 
using CharacterStated_u = ::std::unique_ptr< CharacterStated >
 
using CharacterStated_w = ::std::weak_ptr< CharacterStated >
 
using CharacterStated_const_p = ::std::shared_ptr< const CharacterStated >
 
using CharacterStated_const_u = ::std::unique_ptr< const CharacterStated >
 
using CharacterStated_const_w = ::std::weak_ptr< const CharacterStated >
 
using CollisionGeometryState = CollisionGeometryStateT< float >
 
using CollisionGeometryStated = CollisionGeometryStateT< double >
 
using CollisionGeometryState_p = ::std::shared_ptr< CollisionGeometryState >
 
using CollisionGeometryState_u = ::std::unique_ptr< CollisionGeometryState >
 
using CollisionGeometryState_w = ::std::weak_ptr< CollisionGeometryState >
 
using CollisionGeometryState_const_p = ::std::shared_ptr< const CollisionGeometryState >
 
using CollisionGeometryState_const_u = ::std::unique_ptr< const CollisionGeometryState >
 
using CollisionGeometryState_const_w = ::std::weak_ptr< const CollisionGeometryState >
 
using CollisionGeometryStated_p = ::std::shared_ptr< CollisionGeometryStated >
 
using CollisionGeometryStated_u = ::std::unique_ptr< CollisionGeometryStated >
 
using CollisionGeometryStated_w = ::std::weak_ptr< CollisionGeometryStated >
 
using CollisionGeometryStated_const_p = ::std::shared_ptr< const CollisionGeometryStated >
 
using CollisionGeometryStated_const_u = ::std::unique_ptr< const CollisionGeometryStated >
 
using CollisionGeometryStated_const_w = ::std::weak_ptr< const CollisionGeometryStated >
 
using Joint = JointT< float >
 
using Jointd = JointT< double >
 
using Joint_p = ::std::shared_ptr< Joint >
 
using Joint_u = ::std::unique_ptr< Joint >
 
using Joint_w = ::std::weak_ptr< Joint >
 
using Joint_const_p = ::std::shared_ptr< const Joint >
 
using Joint_const_u = ::std::unique_ptr< const Joint >
 
using Joint_const_w = ::std::weak_ptr< const Joint >
 
using Jointd_p = ::std::shared_ptr< Jointd >
 
using Jointd_u = ::std::unique_ptr< Jointd >
 
using Jointd_w = ::std::weak_ptr< Jointd >
 
using Jointd_const_p = ::std::shared_ptr< const Jointd >
 
using Jointd_const_u = ::std::unique_ptr< const Jointd >
 
using Jointd_const_w = ::std::weak_ptr< const Jointd >
 
using JointState = JointStateT< float >
 
using JointStated = JointStateT< double >
 
using JointState_p = ::std::shared_ptr< JointState >
 
using JointState_u = ::std::unique_ptr< JointState >
 
using JointState_w = ::std::weak_ptr< JointState >
 
using JointState_const_p = ::std::shared_ptr< const JointState >
 
using JointState_const_u = ::std::unique_ptr< const JointState >
 
using JointState_const_w = ::std::weak_ptr< const JointState >
 
using JointStated_p = ::std::shared_ptr< JointStated >
 
using JointStated_u = ::std::unique_ptr< JointStated >
 
using JointStated_w = ::std::weak_ptr< JointStated >
 
using JointStated_const_p = ::std::shared_ptr< const JointStated >
 
using JointStated_const_u = ::std::unique_ptr< const JointStated >
 
using JointStated_const_w = ::std::weak_ptr< const JointStated >
 
using ParameterTransform = ParameterTransformT< float >
 
using ParameterTransformd = ParameterTransformT< double >
 
using ParameterTransform_p = ::std::shared_ptr< ParameterTransform >
 
using ParameterTransform_u = ::std::unique_ptr< ParameterTransform >
 
using ParameterTransform_w = ::std::weak_ptr< ParameterTransform >
 
using ParameterTransform_const_p = ::std::shared_ptr< const ParameterTransform >
 
using ParameterTransform_const_u = ::std::unique_ptr< const ParameterTransform >
 
using ParameterTransform_const_w = ::std::weak_ptr< const ParameterTransform >
 
using ParameterTransformd_p = ::std::shared_ptr< ParameterTransformd >
 
using ParameterTransformd_u = ::std::unique_ptr< ParameterTransformd >
 
using ParameterTransformd_w = ::std::weak_ptr< ParameterTransformd >
 
using ParameterTransformd_const_p = ::std::shared_ptr< const ParameterTransformd >
 
using ParameterTransformd_const_u = ::std::unique_ptr< const ParameterTransformd >
 
using ParameterTransformd_const_w = ::std::weak_ptr< const ParameterTransformd >
 
using Skeleton = SkeletonT< float >
 
using Skeletond = SkeletonT< double >
 
using Skeleton_p = ::std::shared_ptr< Skeleton >
 
using Skeleton_u = ::std::unique_ptr< Skeleton >
 
using Skeleton_w = ::std::weak_ptr< Skeleton >
 
using Skeleton_const_p = ::std::shared_ptr< const Skeleton >
 
using Skeleton_const_u = ::std::unique_ptr< const Skeleton >
 
using Skeleton_const_w = ::std::weak_ptr< const Skeleton >
 
using Skeletond_p = ::std::shared_ptr< Skeletond >
 
using Skeletond_u = ::std::unique_ptr< Skeletond >
 
using Skeletond_w = ::std::weak_ptr< Skeletond >
 
using Skeletond_const_p = ::std::shared_ptr< const Skeletond >
 
using Skeletond_const_u = ::std::unique_ptr< const Skeletond >
 
using Skeletond_const_w = ::std::weak_ptr< const Skeletond >
 
using SkeletonState = SkeletonStateT< float >
 
using SkeletonStated = SkeletonStateT< double >
 
using SkeletonState_p = ::std::shared_ptr< SkeletonState >
 
using SkeletonState_u = ::std::unique_ptr< SkeletonState >
 
using SkeletonState_w = ::std::weak_ptr< SkeletonState >
 
using SkeletonState_const_p = ::std::shared_ptr< const SkeletonState >
 
using SkeletonState_const_u = ::std::unique_ptr< const SkeletonState >
 
using SkeletonState_const_w = ::std::weak_ptr< const SkeletonState >
 
using SkeletonStated_p = ::std::shared_ptr< SkeletonStated >
 
using SkeletonStated_u = ::std::unique_ptr< SkeletonStated >
 
using SkeletonStated_w = ::std::weak_ptr< SkeletonStated >
 
using SkeletonStated_const_p = ::std::shared_ptr< const SkeletonStated >
 
using SkeletonStated_const_u = ::std::unique_ptr< const SkeletonStated >
 
using SkeletonStated_const_w = ::std::weak_ptr< const SkeletonStated >
 
using MeshState = MeshStateT< float >
 
using MeshStated = MeshStateT< double >
 
using MeshState_p = ::std::shared_ptr< MeshState >
 
using MeshState_u = ::std::unique_ptr< MeshState >
 
using MeshState_w = ::std::weak_ptr< MeshState >
 
using MeshState_const_p = ::std::shared_ptr< const MeshState >
 
using MeshState_const_u = ::std::unique_ptr< const MeshState >
 
using MeshState_const_w = ::std::weak_ptr< const MeshState >
 
using MeshStated_p = ::std::shared_ptr< MeshStated >
 
using MeshStated_u = ::std::unique_ptr< MeshStated >
 
using MeshStated_w = ::std::weak_ptr< MeshStated >
 
using MeshStated_const_p = ::std::shared_ptr< const MeshStated >
 
using MeshStated_const_u = ::std::unique_ptr< const MeshStated >
 
using MeshStated_const_w = ::std::weak_ptr< const MeshStated >
 
using TaperedCapsule = TaperedCapsuleT< float >
 
using TaperedCapsuled = TaperedCapsuleT< double >
 
using TaperedCapsule_p = ::std::shared_ptr< TaperedCapsule >
 
using TaperedCapsule_u = ::std::unique_ptr< TaperedCapsule >
 
using TaperedCapsule_w = ::std::weak_ptr< TaperedCapsule >
 
using TaperedCapsule_const_p = ::std::shared_ptr< const TaperedCapsule >
 
using TaperedCapsule_const_u = ::std::unique_ptr< const TaperedCapsule >
 
using TaperedCapsule_const_w = ::std::weak_ptr< const TaperedCapsule >
 
using TaperedCapsuled_p = ::std::shared_ptr< TaperedCapsuled >
 
using TaperedCapsuled_u = ::std::unique_ptr< TaperedCapsuled >
 
using TaperedCapsuled_w = ::std::weak_ptr< TaperedCapsuled >
 
using TaperedCapsuled_const_p = ::std::shared_ptr< const TaperedCapsuled >
 
using TaperedCapsuled_const_u = ::std::unique_ptr< const TaperedCapsuled >
 
using TaperedCapsuled_const_w = ::std::weak_ptr< const TaperedCapsuled >
 
using InverseParameterTransform = InverseParameterTransformT< float >
 
using InverseParameterTransformd = InverseParameterTransformT< double >
 
template<typename T >
using JointListT = std::vector< JointT< T > >
 A list of joints (e.g., of a skeleton).
 
using JointList = JointListT< float >
 
using JointListd = JointListT< double >
 
template<typename T >
using JointStateListT = std::vector< JointStateT< T > >
 Structure describing the state of all joints in a skeleton.
 
using JointStateList = JointStateListT< float >
 
using LocatorList = std::vector< Locator >
 A collection of locators attached to a skeleton.
 
using ParameterLimits = std::vector< ParameterLimit >
 
using ParameterSets = std::unordered_map< std::string, ParameterSet >
 
using PoseConstraints = std::unordered_map< std::string, PoseConstraint >
 
using IndexMatrix = Eigen::Matrix< uint32_t, Eigen::Dynamic, kMaxSkinJoints, Eigen::AutoAlign|Eigen::RowMajor >
 Matrix type for storing joint indices that influence each vertex.
 
using WeightMatrix = Eigen::Matrix< float, Eigen::Dynamic, kMaxSkinJoints, Eigen::AutoAlign|Eigen::RowMajor >
 Matrix type for storing weights of joint influences on each vertex.
 
using SkinnedLocatorList = std::vector< SkinnedLocator >
 A collection of locators attached to a skeleton.
 
template<typename T >
using JointVectorT = Eigen::Matrix< T, kParametersPerJoint, 1 >
 
using JointVector = JointVectorT< float >
 
using ModelParameters = ModelParametersT< float >
 
using ModelParametersd = ModelParametersT< double >
 
using BlendWeights = BlendWeightsT< float >
 
using BlendWeightsd = BlendWeightsT< double >
 
using JointParameters = JointParametersT< float >
 
using JointParametersd = JointParametersT< double >
 
using JointStateListd = JointStateListT< double >
 
using CharacterParameters = CharacterParametersT< float >
 
using CharacterParametersd = CharacterParametersT< double >
 
using MotionParameters = std::tuple< std::vector< std::string >, Eigen::MatrixXf >
 
using IdentityParameters = std::tuple< std::vector< std::string >, JointParameters >
 
using ConstraintDataList = std::vector< ConstraintData >
 A list of ConstraintData.
 
template<typename T >
using optional_ref = std::optional< std::reference_wrapper< T > >
 An optional of a reference.
 
using ConstraintData_p = ::std::shared_ptr< ConstraintData >
 
using ConstraintData_u = ::std::unique_ptr< ConstraintData >
 
using ConstraintData_w = ::std::weak_ptr< ConstraintData >
 
using ConstraintData_const_p = ::std::shared_ptr< const ConstraintData >
 
using ConstraintData_const_u = ::std::unique_ptr< const ConstraintData >
 
using ConstraintData_const_w = ::std::weak_ptr< const ConstraintData >
 
using GaussNewtonSolverQROptions_p = ::std::shared_ptr< GaussNewtonSolverQROptions >
 
using GaussNewtonSolverQROptions_u = ::std::unique_ptr< GaussNewtonSolverQROptions >
 
using GaussNewtonSolverQROptions_w = ::std::weak_ptr< GaussNewtonSolverQROptions >
 
using GaussNewtonSolverQROptions_const_p = ::std::shared_ptr< const GaussNewtonSolverQROptions >
 
using GaussNewtonSolverQROptions_const_u = ::std::unique_ptr< const GaussNewtonSolverQROptions >
 
using GaussNewtonSolverQROptions_const_w = ::std::weak_ptr< const GaussNewtonSolverQROptions >
 
using SimdNormalConstraints_p = ::std::shared_ptr< SimdNormalConstraints >
 
using SimdNormalConstraints_u = ::std::unique_ptr< SimdNormalConstraints >
 
using SimdNormalConstraints_w = ::std::weak_ptr< SimdNormalConstraints >
 
using SimdNormalConstraints_const_p = ::std::shared_ptr< const SimdNormalConstraints >
 
using SimdNormalConstraints_const_u = ::std::unique_ptr< const SimdNormalConstraints >
 
using SimdNormalConstraints_const_w = ::std::weak_ptr< const SimdNormalConstraints >
 
using SimdPlaneConstraints_p = ::std::shared_ptr< SimdPlaneConstraints >
 
using SimdPlaneConstraints_u = ::std::unique_ptr< SimdPlaneConstraints >
 
using SimdPlaneConstraints_w = ::std::weak_ptr< SimdPlaneConstraints >
 
using SimdPlaneConstraints_const_p = ::std::shared_ptr< const SimdPlaneConstraints >
 
using SimdPlaneConstraints_const_u = ::std::unique_ptr< const SimdPlaneConstraints >
 
using SimdPlaneConstraints_const_w = ::std::weak_ptr< const SimdPlaneConstraints >
 
using SimdPositionConstraints_p = ::std::shared_ptr< SimdPositionConstraints >
 
using SimdPositionConstraints_u = ::std::unique_ptr< SimdPositionConstraints >
 
using SimdPositionConstraints_w = ::std::weak_ptr< SimdPositionConstraints >
 
using SimdPositionConstraints_const_p = ::std::shared_ptr< const SimdPositionConstraints >
 
using SimdPositionConstraints_const_u = ::std::unique_ptr< const SimdPositionConstraints >
 
using SimdPositionConstraints_const_w = ::std::weak_ptr< const SimdPositionConstraints >
 
using AimData = AimDataT< float >
 
using AimDatad = AimDataT< double >
 
using AimData_p = ::std::shared_ptr< AimData >
 
using AimData_u = ::std::unique_ptr< AimData >
 
using AimData_w = ::std::weak_ptr< AimData >
 
using AimData_const_p = ::std::shared_ptr< const AimData >
 
using AimData_const_u = ::std::unique_ptr< const AimData >
 
using AimData_const_w = ::std::weak_ptr< const AimData >
 
using AimDatad_p = ::std::shared_ptr< AimDatad >
 
using AimDatad_u = ::std::unique_ptr< AimDatad >
 
using AimDatad_w = ::std::weak_ptr< AimDatad >
 
using AimDatad_const_p = ::std::shared_ptr< const AimDatad >
 
using AimDatad_const_u = ::std::unique_ptr< const AimDatad >
 
using AimDatad_const_w = ::std::weak_ptr< const AimDatad >
 
using FixedAxisData = FixedAxisDataT< float >
 
using FixedAxisDatad = FixedAxisDataT< double >
 
using FixedAxisData_p = ::std::shared_ptr< FixedAxisData >
 
using FixedAxisData_u = ::std::unique_ptr< FixedAxisData >
 
using FixedAxisData_w = ::std::weak_ptr< FixedAxisData >
 
using FixedAxisData_const_p = ::std::shared_ptr< const FixedAxisData >
 
using FixedAxisData_const_u = ::std::unique_ptr< const FixedAxisData >
 
using FixedAxisData_const_w = ::std::weak_ptr< const FixedAxisData >
 
using FixedAxisDatad_p = ::std::shared_ptr< FixedAxisDatad >
 
using FixedAxisDatad_u = ::std::unique_ptr< FixedAxisDatad >
 
using FixedAxisDatad_w = ::std::weak_ptr< FixedAxisDatad >
 
using FixedAxisDatad_const_p = ::std::shared_ptr< const FixedAxisDatad >
 
using FixedAxisDatad_const_u = ::std::unique_ptr< const FixedAxisDatad >
 
using FixedAxisDatad_const_w = ::std::weak_ptr< const FixedAxisDatad >
 
using NormalData = NormalDataT< float >
 
using NormalDatad = NormalDataT< double >
 
using NormalData_p = ::std::shared_ptr< NormalData >
 
using NormalData_u = ::std::unique_ptr< NormalData >
 
using NormalData_w = ::std::weak_ptr< NormalData >
 
using NormalData_const_p = ::std::shared_ptr< const NormalData >
 
using NormalData_const_u = ::std::unique_ptr< const NormalData >
 
using NormalData_const_w = ::std::weak_ptr< const NormalData >
 
using NormalDatad_p = ::std::shared_ptr< NormalDatad >
 
using NormalDatad_u = ::std::unique_ptr< NormalDatad >
 
using NormalDatad_w = ::std::weak_ptr< NormalDatad >
 
using NormalDatad_const_p = ::std::shared_ptr< const NormalDatad >
 
using NormalDatad_const_u = ::std::unique_ptr< const NormalDatad >
 
using NormalDatad_const_w = ::std::weak_ptr< const NormalDatad >
 
using OrientationData = OrientationDataT< float >
 
using OrientationDatad = OrientationDataT< double >
 
using OrientationData_p = ::std::shared_ptr< OrientationData >
 
using OrientationData_u = ::std::unique_ptr< OrientationData >
 
using OrientationData_w = ::std::weak_ptr< OrientationData >
 
using OrientationData_const_p = ::std::shared_ptr< const OrientationData >
 
using OrientationData_const_u = ::std::unique_ptr< const OrientationData >
 
using OrientationData_const_w = ::std::weak_ptr< const OrientationData >
 
using OrientationDatad_p = ::std::shared_ptr< OrientationDatad >
 
using OrientationDatad_u = ::std::unique_ptr< OrientationDatad >
 
using OrientationDatad_w = ::std::weak_ptr< OrientationDatad >
 
using OrientationDatad_const_p = ::std::shared_ptr< const OrientationDatad >
 
using OrientationDatad_const_u = ::std::unique_ptr< const OrientationDatad >
 
using OrientationDatad_const_w = ::std::weak_ptr< const OrientationDatad >
 
using PointTriangleVertexConstraint = PointTriangleVertexConstraintT< float >
 
using PointTriangleVertexConstraintd = PointTriangleVertexConstraintT< double >
 
using PointTriangleVertexConstraint_p = ::std::shared_ptr< PointTriangleVertexConstraint >
 
using PointTriangleVertexConstraint_u = ::std::unique_ptr< PointTriangleVertexConstraint >
 
using PointTriangleVertexConstraint_w = ::std::weak_ptr< PointTriangleVertexConstraint >
 
using PointTriangleVertexConstraint_const_p = ::std::shared_ptr< const PointTriangleVertexConstraint >
 
using PointTriangleVertexConstraint_const_u = ::std::unique_ptr< const PointTriangleVertexConstraint >
 
using PointTriangleVertexConstraint_const_w = ::std::weak_ptr< const PointTriangleVertexConstraint >
 
using PointTriangleVertexConstraintd_p = ::std::shared_ptr< PointTriangleVertexConstraintd >
 
using PointTriangleVertexConstraintd_u = ::std::unique_ptr< PointTriangleVertexConstraintd >
 
using PointTriangleVertexConstraintd_w = ::std::weak_ptr< PointTriangleVertexConstraintd >
 
using PointTriangleVertexConstraintd_const_p = ::std::shared_ptr< const PointTriangleVertexConstraintd >
 
using PointTriangleVertexConstraintd_const_u = ::std::unique_ptr< const PointTriangleVertexConstraintd >
 
using PointTriangleVertexConstraintd_const_w = ::std::weak_ptr< const PointTriangleVertexConstraintd >
 
using PlaneData = PlaneDataT< float >
 
using PlaneDatad = PlaneDataT< double >
 
using PlaneData_p = ::std::shared_ptr< PlaneData >
 
using PlaneData_u = ::std::unique_ptr< PlaneData >
 
using PlaneData_w = ::std::weak_ptr< PlaneData >
 
using PlaneData_const_p = ::std::shared_ptr< const PlaneData >
 
using PlaneData_const_u = ::std::unique_ptr< const PlaneData >
 
using PlaneData_const_w = ::std::weak_ptr< const PlaneData >
 
using PlaneDatad_p = ::std::shared_ptr< PlaneDatad >
 
using PlaneDatad_u = ::std::unique_ptr< PlaneDatad >
 
using PlaneDatad_w = ::std::weak_ptr< PlaneDatad >
 
using PlaneDatad_const_p = ::std::shared_ptr< const PlaneDatad >
 
using PlaneDatad_const_u = ::std::unique_ptr< const PlaneDatad >
 
using PlaneDatad_const_w = ::std::weak_ptr< const PlaneDatad >
 
using PositionData = PositionDataT< float >
 
using PositionDatad = PositionDataT< double >
 
using PositionData_p = ::std::shared_ptr< PositionData >
 
using PositionData_u = ::std::unique_ptr< PositionData >
 
using PositionData_w = ::std::weak_ptr< PositionData >
 
using PositionData_const_p = ::std::shared_ptr< const PositionData >
 
using PositionData_const_u = ::std::unique_ptr< const PositionData >
 
using PositionData_const_w = ::std::weak_ptr< const PositionData >
 
using PositionDatad_p = ::std::shared_ptr< PositionDatad >
 
using PositionDatad_u = ::std::unique_ptr< PositionDatad >
 
using PositionDatad_w = ::std::weak_ptr< PositionDatad >
 
using PositionDatad_const_p = ::std::shared_ptr< const PositionDatad >
 
using PositionDatad_const_u = ::std::unique_ptr< const PositionDatad >
 
using PositionDatad_const_w = ::std::weak_ptr< const PositionDatad >
 
using SkinnedLocatorConstraint = SkinnedLocatorConstraintT< float >
 
using SkinnedLocatorConstraintd = SkinnedLocatorConstraintT< double >
 
using SkinnedLocatorConstraint_p = ::std::shared_ptr< SkinnedLocatorConstraint >
 
using SkinnedLocatorConstraint_u = ::std::unique_ptr< SkinnedLocatorConstraint >
 
using SkinnedLocatorConstraint_w = ::std::weak_ptr< SkinnedLocatorConstraint >
 
using SkinnedLocatorConstraint_const_p = ::std::shared_ptr< const SkinnedLocatorConstraint >
 
using SkinnedLocatorConstraint_const_u = ::std::unique_ptr< const SkinnedLocatorConstraint >
 
using SkinnedLocatorConstraint_const_w = ::std::weak_ptr< const SkinnedLocatorConstraint >
 
using SkinnedLocatorConstraintd_p = ::std::shared_ptr< SkinnedLocatorConstraintd >
 
using SkinnedLocatorConstraintd_u = ::std::unique_ptr< SkinnedLocatorConstraintd >
 
using SkinnedLocatorConstraintd_w = ::std::weak_ptr< SkinnedLocatorConstraintd >
 
using SkinnedLocatorConstraintd_const_p = ::std::shared_ptr< const SkinnedLocatorConstraintd >
 
using SkinnedLocatorConstraintd_const_u = ::std::unique_ptr< const SkinnedLocatorConstraintd >
 
using SkinnedLocatorConstraintd_const_w = ::std::weak_ptr< const SkinnedLocatorConstraintd >
 
using SkinnedLocatorTriangleConstraint = SkinnedLocatorTriangleConstraintT< float >
 
using SkinnedLocatorTriangleConstraintd = SkinnedLocatorTriangleConstraintT< double >
 
using SkinnedLocatorTriangleConstraint_p = ::std::shared_ptr< SkinnedLocatorTriangleConstraint >
 
using SkinnedLocatorTriangleConstraint_u = ::std::unique_ptr< SkinnedLocatorTriangleConstraint >
 
using SkinnedLocatorTriangleConstraint_w = ::std::weak_ptr< SkinnedLocatorTriangleConstraint >
 
using SkinnedLocatorTriangleConstraint_const_p = ::std::shared_ptr< const SkinnedLocatorTriangleConstraint >
 
using SkinnedLocatorTriangleConstraint_const_u = ::std::unique_ptr< const SkinnedLocatorTriangleConstraint >
 
using SkinnedLocatorTriangleConstraint_const_w = ::std::weak_ptr< const SkinnedLocatorTriangleConstraint >
 
using SkinnedLocatorTriangleConstraintd_p = ::std::shared_ptr< SkinnedLocatorTriangleConstraintd >
 
using SkinnedLocatorTriangleConstraintd_u = ::std::unique_ptr< SkinnedLocatorTriangleConstraintd >
 
using SkinnedLocatorTriangleConstraintd_w = ::std::weak_ptr< SkinnedLocatorTriangleConstraintd >
 
using SkinnedLocatorTriangleConstraintd_const_p = ::std::shared_ptr< const SkinnedLocatorTriangleConstraintd >
 
using SkinnedLocatorTriangleConstraintd_const_u = ::std::unique_ptr< const SkinnedLocatorTriangleConstraintd >
 
using SkinnedLocatorTriangleConstraintd_const_w = ::std::weak_ptr< const SkinnedLocatorTriangleConstraintd >
 
using VertexConstraint = VertexConstraintT< float >
 
using VertexConstraintd = VertexConstraintT< double >
 
using VertexConstraint_p = ::std::shared_ptr< VertexConstraint >
 
using VertexConstraint_u = ::std::unique_ptr< VertexConstraint >
 
using VertexConstraint_w = ::std::weak_ptr< VertexConstraint >
 
using VertexConstraint_const_p = ::std::shared_ptr< const VertexConstraint >
 
using VertexConstraint_const_u = ::std::unique_ptr< const VertexConstraint >
 
using VertexConstraint_const_w = ::std::weak_ptr< const VertexConstraint >
 
using VertexConstraintd_p = ::std::shared_ptr< VertexConstraintd >
 
using VertexConstraintd_u = ::std::unique_ptr< VertexConstraintd >
 
using VertexConstraintd_w = ::std::weak_ptr< VertexConstraintd >
 
using VertexConstraintd_const_p = ::std::shared_ptr< const VertexConstraintd >
 
using VertexConstraintd_const_u = ::std::unique_ptr< const VertexConstraintd >
 
using VertexConstraintd_const_w = ::std::weak_ptr< const VertexConstraintd >
 
using VertexProjectionConstraint = VertexProjectionConstraintT< float >
 
using VertexProjectionConstraintd = VertexProjectionConstraintT< double >
 
using VertexProjectionConstraint_p = ::std::shared_ptr< VertexProjectionConstraint >
 
using VertexProjectionConstraint_u = ::std::unique_ptr< VertexProjectionConstraint >
 
using VertexProjectionConstraint_w = ::std::weak_ptr< VertexProjectionConstraint >
 
using VertexProjectionConstraint_const_p = ::std::shared_ptr< const VertexProjectionConstraint >
 
using VertexProjectionConstraint_const_u = ::std::unique_ptr< const VertexProjectionConstraint >
 
using VertexProjectionConstraint_const_w = ::std::weak_ptr< const VertexProjectionConstraint >
 
using VertexProjectionConstraintd_p = ::std::shared_ptr< VertexProjectionConstraintd >
 
using VertexProjectionConstraintd_u = ::std::unique_ptr< VertexProjectionConstraintd >
 
using VertexProjectionConstraintd_w = ::std::weak_ptr< VertexProjectionConstraintd >
 
using VertexProjectionConstraintd_const_p = ::std::shared_ptr< const VertexProjectionConstraintd >
 
using VertexProjectionConstraintd_const_u = ::std::unique_ptr< const VertexProjectionConstraintd >
 
using VertexProjectionConstraintd_const_w = ::std::weak_ptr< const VertexProjectionConstraintd >
 
using SimdNormalErrorFunction_p = ::std::shared_ptr< SimdNormalErrorFunction >
 
using SimdNormalErrorFunction_u = ::std::unique_ptr< SimdNormalErrorFunction >
 
using SimdNormalErrorFunction_w = ::std::weak_ptr< SimdNormalErrorFunction >
 
using SimdNormalErrorFunction_const_p = ::std::shared_ptr< const SimdNormalErrorFunction >
 
using SimdNormalErrorFunction_const_u = ::std::unique_ptr< const SimdNormalErrorFunction >
 
using SimdNormalErrorFunction_const_w = ::std::weak_ptr< const SimdNormalErrorFunction >
 
using SimdPlaneErrorFunction_p = ::std::shared_ptr< SimdPlaneErrorFunction >
 
using SimdPlaneErrorFunction_u = ::std::unique_ptr< SimdPlaneErrorFunction >
 
using SimdPlaneErrorFunction_w = ::std::weak_ptr< SimdPlaneErrorFunction >
 
using SimdPlaneErrorFunction_const_p = ::std::shared_ptr< const SimdPlaneErrorFunction >
 
using SimdPlaneErrorFunction_const_u = ::std::unique_ptr< const SimdPlaneErrorFunction >
 
using SimdPlaneErrorFunction_const_w = ::std::weak_ptr< const SimdPlaneErrorFunction >
 
using SimdPositionErrorFunction_p = ::std::shared_ptr< SimdPositionErrorFunction >
 
using SimdPositionErrorFunction_u = ::std::unique_ptr< SimdPositionErrorFunction >
 
using SimdPositionErrorFunction_w = ::std::weak_ptr< SimdPositionErrorFunction >
 
using SimdPositionErrorFunction_const_p = ::std::shared_ptr< const SimdPositionErrorFunction >
 
using SimdPositionErrorFunction_const_u = ::std::unique_ptr< const SimdPositionErrorFunction >
 
using SimdPositionErrorFunction_const_w = ::std::weak_ptr< const SimdPositionErrorFunction >
 
using SimdNormalErrorFunctionAVX_p = ::std::shared_ptr< SimdNormalErrorFunctionAVX >
 
using SimdNormalErrorFunctionAVX_u = ::std::unique_ptr< SimdNormalErrorFunctionAVX >
 
using SimdNormalErrorFunctionAVX_w = ::std::weak_ptr< SimdNormalErrorFunctionAVX >
 
using SimdNormalErrorFunctionAVX_const_p = ::std::shared_ptr< const SimdNormalErrorFunctionAVX >
 
using SimdNormalErrorFunctionAVX_const_u = ::std::unique_ptr< const SimdNormalErrorFunctionAVX >
 
using SimdNormalErrorFunctionAVX_const_w = ::std::weak_ptr< const SimdNormalErrorFunctionAVX >
 
using SimdPlaneErrorFunctionAVX_p = ::std::shared_ptr< SimdPlaneErrorFunctionAVX >
 
using SimdPlaneErrorFunctionAVX_u = ::std::unique_ptr< SimdPlaneErrorFunctionAVX >
 
using SimdPlaneErrorFunctionAVX_w = ::std::weak_ptr< SimdPlaneErrorFunctionAVX >
 
using SimdPlaneErrorFunctionAVX_const_p = ::std::shared_ptr< const SimdPlaneErrorFunctionAVX >
 
using SimdPlaneErrorFunctionAVX_const_u = ::std::unique_ptr< const SimdPlaneErrorFunctionAVX >
 
using SimdPlaneErrorFunctionAVX_const_w = ::std::weak_ptr< const SimdPlaneErrorFunctionAVX >
 
using SimdPositionErrorFunctionAVX_p = ::std::shared_ptr< SimdPositionErrorFunctionAVX >
 
using SimdPositionErrorFunctionAVX_u = ::std::unique_ptr< SimdPositionErrorFunctionAVX >
 
using SimdPositionErrorFunctionAVX_w = ::std::weak_ptr< SimdPositionErrorFunctionAVX >
 
using SimdPositionErrorFunctionAVX_const_p = ::std::shared_ptr< const SimdPositionErrorFunctionAVX >
 
using SimdPositionErrorFunctionAVX_const_u = ::std::unique_ptr< const SimdPositionErrorFunctionAVX >
 
using SimdPositionErrorFunctionAVX_const_w = ::std::weak_ptr< const SimdPositionErrorFunctionAVX >
 
using AimDirErrorFunction = AimDirErrorFunctionT< float >
 
using AimDirErrorFunctiond = AimDirErrorFunctionT< double >
 
using AimDirErrorFunction_p = ::std::shared_ptr< AimDirErrorFunction >
 
using AimDirErrorFunction_u = ::std::unique_ptr< AimDirErrorFunction >
 
using AimDirErrorFunction_w = ::std::weak_ptr< AimDirErrorFunction >
 
using AimDirErrorFunction_const_p = ::std::shared_ptr< const AimDirErrorFunction >
 
using AimDirErrorFunction_const_u = ::std::unique_ptr< const AimDirErrorFunction >
 
using AimDirErrorFunction_const_w = ::std::weak_ptr< const AimDirErrorFunction >
 
using AimDirErrorFunctiond_p = ::std::shared_ptr< AimDirErrorFunctiond >
 
using AimDirErrorFunctiond_u = ::std::unique_ptr< AimDirErrorFunctiond >
 
using AimDirErrorFunctiond_w = ::std::weak_ptr< AimDirErrorFunctiond >
 
using AimDirErrorFunctiond_const_p = ::std::shared_ptr< const AimDirErrorFunctiond >
 
using AimDirErrorFunctiond_const_u = ::std::unique_ptr< const AimDirErrorFunctiond >
 
using AimDirErrorFunctiond_const_w = ::std::weak_ptr< const AimDirErrorFunctiond >
 
using AimDistErrorFunction = AimDistErrorFunctionT< float >
 
using AimDistErrorFunctiond = AimDistErrorFunctionT< double >
 
using AimDistErrorFunction_p = ::std::shared_ptr< AimDistErrorFunction >
 
using AimDistErrorFunction_u = ::std::unique_ptr< AimDistErrorFunction >
 
using AimDistErrorFunction_w = ::std::weak_ptr< AimDistErrorFunction >
 
using AimDistErrorFunction_const_p = ::std::shared_ptr< const AimDistErrorFunction >
 
using AimDistErrorFunction_const_u = ::std::unique_ptr< const AimDistErrorFunction >
 
using AimDistErrorFunction_const_w = ::std::weak_ptr< const AimDistErrorFunction >
 
using AimDistErrorFunctiond_p = ::std::shared_ptr< AimDistErrorFunctiond >
 
using AimDistErrorFunctiond_u = ::std::unique_ptr< AimDistErrorFunctiond >
 
using AimDistErrorFunctiond_w = ::std::weak_ptr< AimDistErrorFunctiond >
 
using AimDistErrorFunctiond_const_p = ::std::shared_ptr< const AimDistErrorFunctiond >
 
using AimDistErrorFunctiond_const_u = ::std::unique_ptr< const AimDistErrorFunctiond >
 
using AimDistErrorFunctiond_const_w = ::std::weak_ptr< const AimDistErrorFunctiond >
 
using CollisionErrorFunction = CollisionErrorFunctionT< float >
 
using CollisionErrorFunctiond = CollisionErrorFunctionT< double >
 
using CollisionErrorFunction_p = ::std::shared_ptr< CollisionErrorFunction >
 
using CollisionErrorFunction_u = ::std::unique_ptr< CollisionErrorFunction >
 
using CollisionErrorFunction_w = ::std::weak_ptr< CollisionErrorFunction >
 
using CollisionErrorFunction_const_p = ::std::shared_ptr< const CollisionErrorFunction >
 
using CollisionErrorFunction_const_u = ::std::unique_ptr< const CollisionErrorFunction >
 
using CollisionErrorFunction_const_w = ::std::weak_ptr< const CollisionErrorFunction >
 
using CollisionErrorFunctiond_p = ::std::shared_ptr< CollisionErrorFunctiond >
 
using CollisionErrorFunctiond_u = ::std::unique_ptr< CollisionErrorFunctiond >
 
using CollisionErrorFunctiond_w = ::std::weak_ptr< CollisionErrorFunctiond >
 
using CollisionErrorFunctiond_const_p = ::std::shared_ptr< const CollisionErrorFunctiond >
 
using CollisionErrorFunctiond_const_u = ::std::unique_ptr< const CollisionErrorFunctiond >
 
using CollisionErrorFunctiond_const_w = ::std::weak_ptr< const CollisionErrorFunctiond >
 
using CollisionErrorFunctionStateless = CollisionErrorFunctionStatelessT< float >
 
using CollisionErrorFunctionStatelessd = CollisionErrorFunctionStatelessT< double >
 
using CollisionErrorFunctionStateless_p = ::std::shared_ptr< CollisionErrorFunctionStateless >
 
using CollisionErrorFunctionStateless_u = ::std::unique_ptr< CollisionErrorFunctionStateless >
 
using CollisionErrorFunctionStateless_w = ::std::weak_ptr< CollisionErrorFunctionStateless >
 
using CollisionErrorFunctionStateless_const_p = ::std::shared_ptr< const CollisionErrorFunctionStateless >
 
using CollisionErrorFunctionStateless_const_u = ::std::unique_ptr< const CollisionErrorFunctionStateless >
 
using CollisionErrorFunctionStateless_const_w = ::std::weak_ptr< const CollisionErrorFunctionStateless >
 
using CollisionErrorFunctionStatelessd_p = ::std::shared_ptr< CollisionErrorFunctionStatelessd >
 
using CollisionErrorFunctionStatelessd_u = ::std::unique_ptr< CollisionErrorFunctionStatelessd >
 
using CollisionErrorFunctionStatelessd_w = ::std::weak_ptr< CollisionErrorFunctionStatelessd >
 
using CollisionErrorFunctionStatelessd_const_p = ::std::shared_ptr< const CollisionErrorFunctionStatelessd >
 
using CollisionErrorFunctionStatelessd_const_u = ::std::unique_ptr< const CollisionErrorFunctionStatelessd >
 
using CollisionErrorFunctionStatelessd_const_w = ::std::weak_ptr< const CollisionErrorFunctionStatelessd >
 
using DistanceErrorFunction = DistanceErrorFunctionT< float >
 
using DistanceErrorFunctiond = DistanceErrorFunctionT< double >
 
using DistanceErrorFunction_p = ::std::shared_ptr< DistanceErrorFunction >
 
using DistanceErrorFunction_u = ::std::unique_ptr< DistanceErrorFunction >
 
using DistanceErrorFunction_w = ::std::weak_ptr< DistanceErrorFunction >
 
using DistanceErrorFunction_const_p = ::std::shared_ptr< const DistanceErrorFunction >
 
using DistanceErrorFunction_const_u = ::std::unique_ptr< const DistanceErrorFunction >
 
using DistanceErrorFunction_const_w = ::std::weak_ptr< const DistanceErrorFunction >
 
using DistanceErrorFunctiond_p = ::std::shared_ptr< DistanceErrorFunctiond >
 
using DistanceErrorFunctiond_u = ::std::unique_ptr< DistanceErrorFunctiond >
 
using DistanceErrorFunctiond_w = ::std::weak_ptr< DistanceErrorFunctiond >
 
using DistanceErrorFunctiond_const_p = ::std::shared_ptr< const DistanceErrorFunctiond >
 
using DistanceErrorFunctiond_const_u = ::std::unique_ptr< const DistanceErrorFunctiond >
 
using DistanceErrorFunctiond_const_w = ::std::weak_ptr< const DistanceErrorFunctiond >
 
using FixedAxisAngleErrorFunction = FixedAxisAngleErrorFunctionT< float >
 
using FixedAxisAngleErrorFunctiond = FixedAxisAngleErrorFunctionT< double >
 
using FixedAxisAngleErrorFunction_p = ::std::shared_ptr< FixedAxisAngleErrorFunction >
 
using FixedAxisAngleErrorFunction_u = ::std::unique_ptr< FixedAxisAngleErrorFunction >
 
using FixedAxisAngleErrorFunction_w = ::std::weak_ptr< FixedAxisAngleErrorFunction >
 
using FixedAxisAngleErrorFunction_const_p = ::std::shared_ptr< const FixedAxisAngleErrorFunction >
 
using FixedAxisAngleErrorFunction_const_u = ::std::unique_ptr< const FixedAxisAngleErrorFunction >
 
using FixedAxisAngleErrorFunction_const_w = ::std::weak_ptr< const FixedAxisAngleErrorFunction >
 
using FixedAxisAngleErrorFunctiond_p = ::std::shared_ptr< FixedAxisAngleErrorFunctiond >
 
using FixedAxisAngleErrorFunctiond_u = ::std::unique_ptr< FixedAxisAngleErrorFunctiond >
 
using FixedAxisAngleErrorFunctiond_w = ::std::weak_ptr< FixedAxisAngleErrorFunctiond >
 
using FixedAxisAngleErrorFunctiond_const_p = ::std::shared_ptr< const FixedAxisAngleErrorFunctiond >
 
using FixedAxisAngleErrorFunctiond_const_u = ::std::unique_ptr< const FixedAxisAngleErrorFunctiond >
 
using FixedAxisAngleErrorFunctiond_const_w = ::std::weak_ptr< const FixedAxisAngleErrorFunctiond >
 
using FixedAxisCosErrorFunction = FixedAxisCosErrorFunctionT< float >
 
using FixedAxisCosErrorFunctiond = FixedAxisCosErrorFunctionT< double >
 
using FixedAxisCosErrorFunction_p = ::std::shared_ptr< FixedAxisCosErrorFunction >
 
using FixedAxisCosErrorFunction_u = ::std::unique_ptr< FixedAxisCosErrorFunction >
 
using FixedAxisCosErrorFunction_w = ::std::weak_ptr< FixedAxisCosErrorFunction >
 
using FixedAxisCosErrorFunction_const_p = ::std::shared_ptr< const FixedAxisCosErrorFunction >
 
using FixedAxisCosErrorFunction_const_u = ::std::unique_ptr< const FixedAxisCosErrorFunction >
 
using FixedAxisCosErrorFunction_const_w = ::std::weak_ptr< const FixedAxisCosErrorFunction >
 
using FixedAxisCosErrorFunctiond_p = ::std::shared_ptr< FixedAxisCosErrorFunctiond >
 
using FixedAxisCosErrorFunctiond_u = ::std::unique_ptr< FixedAxisCosErrorFunctiond >
 
using FixedAxisCosErrorFunctiond_w = ::std::weak_ptr< FixedAxisCosErrorFunctiond >
 
using FixedAxisCosErrorFunctiond_const_p = ::std::shared_ptr< const FixedAxisCosErrorFunctiond >
 
using FixedAxisCosErrorFunctiond_const_u = ::std::unique_ptr< const FixedAxisCosErrorFunctiond >
 
using FixedAxisCosErrorFunctiond_const_w = ::std::weak_ptr< const FixedAxisCosErrorFunctiond >
 
using FixedAxisDiffErrorFunction = FixedAxisDiffErrorFunctionT< float >
 
using FixedAxisDiffErrorFunctiond = FixedAxisDiffErrorFunctionT< double >
 
using FixedAxisDiffErrorFunction_p = ::std::shared_ptr< FixedAxisDiffErrorFunction >
 
using FixedAxisDiffErrorFunction_u = ::std::unique_ptr< FixedAxisDiffErrorFunction >
 
using FixedAxisDiffErrorFunction_w = ::std::weak_ptr< FixedAxisDiffErrorFunction >
 
using FixedAxisDiffErrorFunction_const_p = ::std::shared_ptr< const FixedAxisDiffErrorFunction >
 
using FixedAxisDiffErrorFunction_const_u = ::std::unique_ptr< const FixedAxisDiffErrorFunction >
 
using FixedAxisDiffErrorFunction_const_w = ::std::weak_ptr< const FixedAxisDiffErrorFunction >
 
using FixedAxisDiffErrorFunctiond_p = ::std::shared_ptr< FixedAxisDiffErrorFunctiond >
 
using FixedAxisDiffErrorFunctiond_u = ::std::unique_ptr< FixedAxisDiffErrorFunctiond >
 
using FixedAxisDiffErrorFunctiond_w = ::std::weak_ptr< FixedAxisDiffErrorFunctiond >
 
using FixedAxisDiffErrorFunctiond_const_p = ::std::shared_ptr< const FixedAxisDiffErrorFunctiond >
 
using FixedAxisDiffErrorFunctiond_const_u = ::std::unique_ptr< const FixedAxisDiffErrorFunctiond >
 
using FixedAxisDiffErrorFunctiond_const_w = ::std::weak_ptr< const FixedAxisDiffErrorFunctiond >
 
using GaussNewtonSolverQR = GaussNewtonSolverQRT< float >
 
using GaussNewtonSolverQRd = GaussNewtonSolverQRT< double >
 
using GaussNewtonSolverQR_p = ::std::shared_ptr< GaussNewtonSolverQR >
 
using GaussNewtonSolverQR_u = ::std::unique_ptr< GaussNewtonSolverQR >
 
using GaussNewtonSolverQR_w = ::std::weak_ptr< GaussNewtonSolverQR >
 
using GaussNewtonSolverQR_const_p = ::std::shared_ptr< const GaussNewtonSolverQR >
 
using GaussNewtonSolverQR_const_u = ::std::unique_ptr< const GaussNewtonSolverQR >
 
using GaussNewtonSolverQR_const_w = ::std::weak_ptr< const GaussNewtonSolverQR >
 
using GaussNewtonSolverQRd_p = ::std::shared_ptr< GaussNewtonSolverQRd >
 
using GaussNewtonSolverQRd_u = ::std::unique_ptr< GaussNewtonSolverQRd >
 
using GaussNewtonSolverQRd_w = ::std::weak_ptr< GaussNewtonSolverQRd >
 
using GaussNewtonSolverQRd_const_p = ::std::shared_ptr< const GaussNewtonSolverQRd >
 
using GaussNewtonSolverQRd_const_u = ::std::unique_ptr< const GaussNewtonSolverQRd >
 
using GaussNewtonSolverQRd_const_w = ::std::weak_ptr< const GaussNewtonSolverQRd >
 
using HeightErrorFunction = HeightErrorFunctionT< float >
 
using HeightErrorFunctiond = HeightErrorFunctionT< double >
 
using HeightErrorFunction_p = ::std::shared_ptr< HeightErrorFunction >
 
using HeightErrorFunction_u = ::std::unique_ptr< HeightErrorFunction >
 
using HeightErrorFunction_w = ::std::weak_ptr< HeightErrorFunction >
 
using HeightErrorFunction_const_p = ::std::shared_ptr< const HeightErrorFunction >
 
using HeightErrorFunction_const_u = ::std::unique_ptr< const HeightErrorFunction >
 
using HeightErrorFunction_const_w = ::std::weak_ptr< const HeightErrorFunction >
 
using HeightErrorFunctiond_p = ::std::shared_ptr< HeightErrorFunctiond >
 
using HeightErrorFunctiond_u = ::std::unique_ptr< HeightErrorFunctiond >
 
using HeightErrorFunctiond_w = ::std::weak_ptr< HeightErrorFunctiond >
 
using HeightErrorFunctiond_const_p = ::std::shared_ptr< const HeightErrorFunctiond >
 
using HeightErrorFunctiond_const_u = ::std::unique_ptr< const HeightErrorFunctiond >
 
using HeightErrorFunctiond_const_w = ::std::weak_ptr< const HeightErrorFunctiond >
 
using LimitErrorFunction = LimitErrorFunctionT< float >
 
using LimitErrorFunctiond = LimitErrorFunctionT< double >
 
using LimitErrorFunction_p = ::std::shared_ptr< LimitErrorFunction >
 
using LimitErrorFunction_u = ::std::unique_ptr< LimitErrorFunction >
 
using LimitErrorFunction_w = ::std::weak_ptr< LimitErrorFunction >
 
using LimitErrorFunction_const_p = ::std::shared_ptr< const LimitErrorFunction >
 
using LimitErrorFunction_const_u = ::std::unique_ptr< const LimitErrorFunction >
 
using LimitErrorFunction_const_w = ::std::weak_ptr< const LimitErrorFunction >
 
using LimitErrorFunctiond_p = ::std::shared_ptr< LimitErrorFunctiond >
 
using LimitErrorFunctiond_u = ::std::unique_ptr< LimitErrorFunctiond >
 
using LimitErrorFunctiond_w = ::std::weak_ptr< LimitErrorFunctiond >
 
using LimitErrorFunctiond_const_p = ::std::shared_ptr< const LimitErrorFunctiond >
 
using LimitErrorFunctiond_const_u = ::std::unique_ptr< const LimitErrorFunctiond >
 
using LimitErrorFunctiond_const_w = ::std::weak_ptr< const LimitErrorFunctiond >
 
using ModelParametersErrorFunction = ModelParametersErrorFunctionT< float >
 
using ModelParametersErrorFunctiond = ModelParametersErrorFunctionT< double >
 
using ModelParametersErrorFunction_p = ::std::shared_ptr< ModelParametersErrorFunction >
 
using ModelParametersErrorFunction_u = ::std::unique_ptr< ModelParametersErrorFunction >
 
using ModelParametersErrorFunction_w = ::std::weak_ptr< ModelParametersErrorFunction >
 
using ModelParametersErrorFunction_const_p = ::std::shared_ptr< const ModelParametersErrorFunction >
 
using ModelParametersErrorFunction_const_u = ::std::unique_ptr< const ModelParametersErrorFunction >
 
using ModelParametersErrorFunction_const_w = ::std::weak_ptr< const ModelParametersErrorFunction >
 
using ModelParametersErrorFunctiond_p = ::std::shared_ptr< ModelParametersErrorFunctiond >
 
using ModelParametersErrorFunctiond_u = ::std::unique_ptr< ModelParametersErrorFunctiond >
 
using ModelParametersErrorFunctiond_w = ::std::weak_ptr< ModelParametersErrorFunctiond >
 
using ModelParametersErrorFunctiond_const_p = ::std::shared_ptr< const ModelParametersErrorFunctiond >
 
using ModelParametersErrorFunctiond_const_u = ::std::unique_ptr< const ModelParametersErrorFunctiond >
 
using ModelParametersErrorFunctiond_const_w = ::std::weak_ptr< const ModelParametersErrorFunctiond >
 
using NormalErrorFunction = NormalErrorFunctionT< float >
 
using NormalErrorFunctiond = NormalErrorFunctionT< double >
 
using NormalErrorFunction_p = ::std::shared_ptr< NormalErrorFunction >
 
using NormalErrorFunction_u = ::std::unique_ptr< NormalErrorFunction >
 
using NormalErrorFunction_w = ::std::weak_ptr< NormalErrorFunction >
 
using NormalErrorFunction_const_p = ::std::shared_ptr< const NormalErrorFunction >
 
using NormalErrorFunction_const_u = ::std::unique_ptr< const NormalErrorFunction >
 
using NormalErrorFunction_const_w = ::std::weak_ptr< const NormalErrorFunction >
 
using NormalErrorFunctiond_p = ::std::shared_ptr< NormalErrorFunctiond >
 
using NormalErrorFunctiond_u = ::std::unique_ptr< NormalErrorFunctiond >
 
using NormalErrorFunctiond_w = ::std::weak_ptr< NormalErrorFunctiond >
 
using NormalErrorFunctiond_const_p = ::std::shared_ptr< const NormalErrorFunctiond >
 
using NormalErrorFunctiond_const_u = ::std::unique_ptr< const NormalErrorFunctiond >
 
using NormalErrorFunctiond_const_w = ::std::weak_ptr< const NormalErrorFunctiond >
 
using OrientationErrorFunction = OrientationErrorFunctionT< float >
 
using OrientationErrorFunctiond = OrientationErrorFunctionT< double >
 
using OrientationErrorFunction_p = ::std::shared_ptr< OrientationErrorFunction >
 
using OrientationErrorFunction_u = ::std::unique_ptr< OrientationErrorFunction >
 
using OrientationErrorFunction_w = ::std::weak_ptr< OrientationErrorFunction >
 
using OrientationErrorFunction_const_p = ::std::shared_ptr< const OrientationErrorFunction >
 
using OrientationErrorFunction_const_u = ::std::unique_ptr< const OrientationErrorFunction >
 
using OrientationErrorFunction_const_w = ::std::weak_ptr< const OrientationErrorFunction >
 
using OrientationErrorFunctiond_p = ::std::shared_ptr< OrientationErrorFunctiond >
 
using OrientationErrorFunctiond_u = ::std::unique_ptr< OrientationErrorFunctiond >
 
using OrientationErrorFunctiond_w = ::std::weak_ptr< OrientationErrorFunctiond >
 
using OrientationErrorFunctiond_const_p = ::std::shared_ptr< const OrientationErrorFunctiond >
 
using OrientationErrorFunctiond_const_u = ::std::unique_ptr< const OrientationErrorFunctiond >
 
using OrientationErrorFunctiond_const_w = ::std::weak_ptr< const OrientationErrorFunctiond >
 
using PlaneErrorFunction = PlaneErrorFunctionT< float >
 
using PlaneErrorFunctiond = PlaneErrorFunctionT< double >
 
using PlaneErrorFunction_p = ::std::shared_ptr< PlaneErrorFunction >
 
using PlaneErrorFunction_u = ::std::unique_ptr< PlaneErrorFunction >
 
using PlaneErrorFunction_w = ::std::weak_ptr< PlaneErrorFunction >
 
using PlaneErrorFunction_const_p = ::std::shared_ptr< const PlaneErrorFunction >
 
using PlaneErrorFunction_const_u = ::std::unique_ptr< const PlaneErrorFunction >
 
using PlaneErrorFunction_const_w = ::std::weak_ptr< const PlaneErrorFunction >
 
using PlaneErrorFunctiond_p = ::std::shared_ptr< PlaneErrorFunctiond >
 
using PlaneErrorFunctiond_u = ::std::unique_ptr< PlaneErrorFunctiond >
 
using PlaneErrorFunctiond_w = ::std::weak_ptr< PlaneErrorFunctiond >
 
using PlaneErrorFunctiond_const_p = ::std::shared_ptr< const PlaneErrorFunctiond >
 
using PlaneErrorFunctiond_const_u = ::std::unique_ptr< const PlaneErrorFunctiond >
 
using PlaneErrorFunctiond_const_w = ::std::weak_ptr< const PlaneErrorFunctiond >
 
using PointTriangleVertexErrorFunction = PointTriangleVertexErrorFunctionT< float >
 
using PointTriangleVertexErrorFunctiond = PointTriangleVertexErrorFunctionT< double >
 
using PointTriangleVertexErrorFunction_p = ::std::shared_ptr< PointTriangleVertexErrorFunction >
 
using PointTriangleVertexErrorFunction_u = ::std::unique_ptr< PointTriangleVertexErrorFunction >
 
using PointTriangleVertexErrorFunction_w = ::std::weak_ptr< PointTriangleVertexErrorFunction >
 
using PointTriangleVertexErrorFunction_const_p = ::std::shared_ptr< const PointTriangleVertexErrorFunction >
 
using PointTriangleVertexErrorFunction_const_u = ::std::unique_ptr< const PointTriangleVertexErrorFunction >
 
using PointTriangleVertexErrorFunction_const_w = ::std::weak_ptr< const PointTriangleVertexErrorFunction >
 
using PointTriangleVertexErrorFunctiond_p = ::std::shared_ptr< PointTriangleVertexErrorFunctiond >
 
using PointTriangleVertexErrorFunctiond_u = ::std::unique_ptr< PointTriangleVertexErrorFunctiond >
 
using PointTriangleVertexErrorFunctiond_w = ::std::weak_ptr< PointTriangleVertexErrorFunctiond >
 
using PointTriangleVertexErrorFunctiond_const_p = ::std::shared_ptr< const PointTriangleVertexErrorFunctiond >
 
using PointTriangleVertexErrorFunctiond_const_u = ::std::unique_ptr< const PointTriangleVertexErrorFunctiond >
 
using PointTriangleVertexErrorFunctiond_const_w = ::std::weak_ptr< const PointTriangleVertexErrorFunctiond >
 
using PosePriorErrorFunction = PosePriorErrorFunctionT< float >
 
using PosePriorErrorFunctiond = PosePriorErrorFunctionT< double >
 
using PosePriorErrorFunction_p = ::std::shared_ptr< PosePriorErrorFunction >
 
using PosePriorErrorFunction_u = ::std::unique_ptr< PosePriorErrorFunction >
 
using PosePriorErrorFunction_w = ::std::weak_ptr< PosePriorErrorFunction >
 
using PosePriorErrorFunction_const_p = ::std::shared_ptr< const PosePriorErrorFunction >
 
using PosePriorErrorFunction_const_u = ::std::unique_ptr< const PosePriorErrorFunction >
 
using PosePriorErrorFunction_const_w = ::std::weak_ptr< const PosePriorErrorFunction >
 
using PosePriorErrorFunctiond_p = ::std::shared_ptr< PosePriorErrorFunctiond >
 
using PosePriorErrorFunctiond_u = ::std::unique_ptr< PosePriorErrorFunctiond >
 
using PosePriorErrorFunctiond_w = ::std::weak_ptr< PosePriorErrorFunctiond >
 
using PosePriorErrorFunctiond_const_p = ::std::shared_ptr< const PosePriorErrorFunctiond >
 
using PosePriorErrorFunctiond_const_u = ::std::unique_ptr< const PosePriorErrorFunctiond >
 
using PosePriorErrorFunctiond_const_w = ::std::weak_ptr< const PosePriorErrorFunctiond >
 
using PoseTransformSolver = PoseTransformSolverT< float >
 
using PoseTransformSolverd = PoseTransformSolverT< double >
 
using PoseTransformSolver_p = ::std::shared_ptr< PoseTransformSolver >
 
using PoseTransformSolver_u = ::std::unique_ptr< PoseTransformSolver >
 
using PoseTransformSolver_w = ::std::weak_ptr< PoseTransformSolver >
 
using PoseTransformSolver_const_p = ::std::shared_ptr< const PoseTransformSolver >
 
using PoseTransformSolver_const_u = ::std::unique_ptr< const PoseTransformSolver >
 
using PoseTransformSolver_const_w = ::std::weak_ptr< const PoseTransformSolver >
 
using PoseTransformSolverd_p = ::std::shared_ptr< PoseTransformSolverd >
 
using PoseTransformSolverd_u = ::std::unique_ptr< PoseTransformSolverd >
 
using PoseTransformSolverd_w = ::std::weak_ptr< PoseTransformSolverd >
 
using PoseTransformSolverd_const_p = ::std::shared_ptr< const PoseTransformSolverd >
 
using PoseTransformSolverd_const_u = ::std::unique_ptr< const PoseTransformSolverd >
 
using PoseTransformSolverd_const_w = ::std::weak_ptr< const PoseTransformSolverd >
 
using PositionErrorFunction = PositionErrorFunctionT< float >
 
using PositionErrorFunctiond = PositionErrorFunctionT< double >
 
using PositionErrorFunction_p = ::std::shared_ptr< PositionErrorFunction >
 
using PositionErrorFunction_u = ::std::unique_ptr< PositionErrorFunction >
 
using PositionErrorFunction_w = ::std::weak_ptr< PositionErrorFunction >
 
using PositionErrorFunction_const_p = ::std::shared_ptr< const PositionErrorFunction >
 
using PositionErrorFunction_const_u = ::std::unique_ptr< const PositionErrorFunction >
 
using PositionErrorFunction_const_w = ::std::weak_ptr< const PositionErrorFunction >
 
using PositionErrorFunctiond_p = ::std::shared_ptr< PositionErrorFunctiond >
 
using PositionErrorFunctiond_u = ::std::unique_ptr< PositionErrorFunctiond >
 
using PositionErrorFunctiond_w = ::std::weak_ptr< PositionErrorFunctiond >
 
using PositionErrorFunctiond_const_p = ::std::shared_ptr< const PositionErrorFunctiond >
 
using PositionErrorFunctiond_const_u = ::std::unique_ptr< const PositionErrorFunctiond >
 
using PositionErrorFunctiond_const_w = ::std::weak_ptr< const PositionErrorFunctiond >
 
using ProjectionErrorFunction = ProjectionErrorFunctionT< float >
 
using ProjectionErrorFunctiond = ProjectionErrorFunctionT< double >
 
using ProjectionErrorFunction_p = ::std::shared_ptr< ProjectionErrorFunction >
 
using ProjectionErrorFunction_u = ::std::unique_ptr< ProjectionErrorFunction >
 
using ProjectionErrorFunction_w = ::std::weak_ptr< ProjectionErrorFunction >
 
using ProjectionErrorFunction_const_p = ::std::shared_ptr< const ProjectionErrorFunction >
 
using ProjectionErrorFunction_const_u = ::std::unique_ptr< const ProjectionErrorFunction >
 
using ProjectionErrorFunction_const_w = ::std::weak_ptr< const ProjectionErrorFunction >
 
using ProjectionErrorFunctiond_p = ::std::shared_ptr< ProjectionErrorFunctiond >
 
using ProjectionErrorFunctiond_u = ::std::unique_ptr< ProjectionErrorFunctiond >
 
using ProjectionErrorFunctiond_w = ::std::weak_ptr< ProjectionErrorFunctiond >
 
using ProjectionErrorFunctiond_const_p = ::std::shared_ptr< const ProjectionErrorFunctiond >
 
using ProjectionErrorFunctiond_const_u = ::std::unique_ptr< const ProjectionErrorFunctiond >
 
using ProjectionErrorFunctiond_const_w = ::std::weak_ptr< const ProjectionErrorFunctiond >
 
using SimdCollisionErrorFunction = SimdCollisionErrorFunctionT< float >
 
using SimdCollisionErrorFunctiond = SimdCollisionErrorFunctionT< double >
 
using SimdCollisionErrorFunction_p = ::std::shared_ptr< SimdCollisionErrorFunction >
 
using SimdCollisionErrorFunction_u = ::std::unique_ptr< SimdCollisionErrorFunction >
 
using SimdCollisionErrorFunction_w = ::std::weak_ptr< SimdCollisionErrorFunction >
 
using SimdCollisionErrorFunction_const_p = ::std::shared_ptr< const SimdCollisionErrorFunction >
 
using SimdCollisionErrorFunction_const_u = ::std::unique_ptr< const SimdCollisionErrorFunction >
 
using SimdCollisionErrorFunction_const_w = ::std::weak_ptr< const SimdCollisionErrorFunction >
 
using SimdCollisionErrorFunctiond_p = ::std::shared_ptr< SimdCollisionErrorFunctiond >
 
using SimdCollisionErrorFunctiond_u = ::std::unique_ptr< SimdCollisionErrorFunctiond >
 
using SimdCollisionErrorFunctiond_w = ::std::weak_ptr< SimdCollisionErrorFunctiond >
 
using SimdCollisionErrorFunctiond_const_p = ::std::shared_ptr< const SimdCollisionErrorFunctiond >
 
using SimdCollisionErrorFunctiond_const_u = ::std::unique_ptr< const SimdCollisionErrorFunctiond >
 
using SimdCollisionErrorFunctiond_const_w = ::std::weak_ptr< const SimdCollisionErrorFunctiond >
 
using SkeletonErrorFunction = SkeletonErrorFunctionT< float >
 
using SkeletonErrorFunctiond = SkeletonErrorFunctionT< double >
 
using SkeletonErrorFunction_p = ::std::shared_ptr< SkeletonErrorFunction >
 
using SkeletonErrorFunction_u = ::std::unique_ptr< SkeletonErrorFunction >
 
using SkeletonErrorFunction_w = ::std::weak_ptr< SkeletonErrorFunction >
 
using SkeletonErrorFunction_const_p = ::std::shared_ptr< const SkeletonErrorFunction >
 
using SkeletonErrorFunction_const_u = ::std::unique_ptr< const SkeletonErrorFunction >
 
using SkeletonErrorFunction_const_w = ::std::weak_ptr< const SkeletonErrorFunction >
 
using SkeletonErrorFunctiond_p = ::std::shared_ptr< SkeletonErrorFunctiond >
 
using SkeletonErrorFunctiond_u = ::std::unique_ptr< SkeletonErrorFunctiond >
 
using SkeletonErrorFunctiond_w = ::std::weak_ptr< SkeletonErrorFunctiond >
 
using SkeletonErrorFunctiond_const_p = ::std::shared_ptr< const SkeletonErrorFunctiond >
 
using SkeletonErrorFunctiond_const_u = ::std::unique_ptr< const SkeletonErrorFunctiond >
 
using SkeletonErrorFunctiond_const_w = ::std::weak_ptr< const SkeletonErrorFunctiond >
 
using SkeletonSolverFunction = SkeletonSolverFunctionT< float >
 
using SkeletonSolverFunctiond = SkeletonSolverFunctionT< double >
 
using SkeletonSolverFunction_p = ::std::shared_ptr< SkeletonSolverFunction >
 
using SkeletonSolverFunction_u = ::std::unique_ptr< SkeletonSolverFunction >
 
using SkeletonSolverFunction_w = ::std::weak_ptr< SkeletonSolverFunction >
 
using SkeletonSolverFunction_const_p = ::std::shared_ptr< const SkeletonSolverFunction >
 
using SkeletonSolverFunction_const_u = ::std::unique_ptr< const SkeletonSolverFunction >
 
using SkeletonSolverFunction_const_w = ::std::weak_ptr< const SkeletonSolverFunction >
 
using SkeletonSolverFunctiond_p = ::std::shared_ptr< SkeletonSolverFunctiond >
 
using SkeletonSolverFunctiond_u = ::std::unique_ptr< SkeletonSolverFunctiond >
 
using SkeletonSolverFunctiond_w = ::std::weak_ptr< SkeletonSolverFunctiond >
 
using SkeletonSolverFunctiond_const_p = ::std::shared_ptr< const SkeletonSolverFunctiond >
 
using SkeletonSolverFunctiond_const_u = ::std::unique_ptr< const SkeletonSolverFunctiond >
 
using SkeletonSolverFunctiond_const_w = ::std::weak_ptr< const SkeletonSolverFunctiond >
 
using SkinnedLocatorErrorFunction = SkinnedLocatorErrorFunctionT< float >
 
using SkinnedLocatorErrorFunctiond = SkinnedLocatorErrorFunctionT< double >
 
using SkinnedLocatorErrorFunction_p = ::std::shared_ptr< SkinnedLocatorErrorFunction >
 
using SkinnedLocatorErrorFunction_u = ::std::unique_ptr< SkinnedLocatorErrorFunction >
 
using SkinnedLocatorErrorFunction_w = ::std::weak_ptr< SkinnedLocatorErrorFunction >
 
using SkinnedLocatorErrorFunction_const_p = ::std::shared_ptr< const SkinnedLocatorErrorFunction >
 
using SkinnedLocatorErrorFunction_const_u = ::std::unique_ptr< const SkinnedLocatorErrorFunction >
 
using SkinnedLocatorErrorFunction_const_w = ::std::weak_ptr< const SkinnedLocatorErrorFunction >
 
using SkinnedLocatorErrorFunctiond_p = ::std::shared_ptr< SkinnedLocatorErrorFunctiond >
 
using SkinnedLocatorErrorFunctiond_u = ::std::unique_ptr< SkinnedLocatorErrorFunctiond >
 
using SkinnedLocatorErrorFunctiond_w = ::std::weak_ptr< SkinnedLocatorErrorFunctiond >
 
using SkinnedLocatorErrorFunctiond_const_p = ::std::shared_ptr< const SkinnedLocatorErrorFunctiond >
 
using SkinnedLocatorErrorFunctiond_const_u = ::std::unique_ptr< const SkinnedLocatorErrorFunctiond >
 
using SkinnedLocatorErrorFunctiond_const_w = ::std::weak_ptr< const SkinnedLocatorErrorFunctiond >
 
using SkinnedLocatorTriangleErrorFunction = SkinnedLocatorTriangleErrorFunctionT< float >
 
using SkinnedLocatorTriangleErrorFunctiond = SkinnedLocatorTriangleErrorFunctionT< double >
 
using SkinnedLocatorTriangleErrorFunction_p = ::std::shared_ptr< SkinnedLocatorTriangleErrorFunction >
 
using SkinnedLocatorTriangleErrorFunction_u = ::std::unique_ptr< SkinnedLocatorTriangleErrorFunction >
 
using SkinnedLocatorTriangleErrorFunction_w = ::std::weak_ptr< SkinnedLocatorTriangleErrorFunction >
 
using SkinnedLocatorTriangleErrorFunction_const_p = ::std::shared_ptr< const SkinnedLocatorTriangleErrorFunction >
 
using SkinnedLocatorTriangleErrorFunction_const_u = ::std::unique_ptr< const SkinnedLocatorTriangleErrorFunction >
 
using SkinnedLocatorTriangleErrorFunction_const_w = ::std::weak_ptr< const SkinnedLocatorTriangleErrorFunction >
 
using SkinnedLocatorTriangleErrorFunctiond_p = ::std::shared_ptr< SkinnedLocatorTriangleErrorFunctiond >
 
using SkinnedLocatorTriangleErrorFunctiond_u = ::std::unique_ptr< SkinnedLocatorTriangleErrorFunctiond >
 
using SkinnedLocatorTriangleErrorFunctiond_w = ::std::weak_ptr< SkinnedLocatorTriangleErrorFunctiond >
 
using SkinnedLocatorTriangleErrorFunctiond_const_p = ::std::shared_ptr< const SkinnedLocatorTriangleErrorFunctiond >
 
using SkinnedLocatorTriangleErrorFunctiond_const_u = ::std::unique_ptr< const SkinnedLocatorTriangleErrorFunctiond >
 
using SkinnedLocatorTriangleErrorFunctiond_const_w = ::std::weak_ptr< const SkinnedLocatorTriangleErrorFunctiond >
 
using StateErrorFunction = StateErrorFunctionT< float >
 
using StateErrorFunctiond = StateErrorFunctionT< double >
 
using StateErrorFunction_p = ::std::shared_ptr< StateErrorFunction >
 
using StateErrorFunction_u = ::std::unique_ptr< StateErrorFunction >
 
using StateErrorFunction_w = ::std::weak_ptr< StateErrorFunction >
 
using StateErrorFunction_const_p = ::std::shared_ptr< const StateErrorFunction >
 
using StateErrorFunction_const_u = ::std::unique_ptr< const StateErrorFunction >
 
using StateErrorFunction_const_w = ::std::weak_ptr< const StateErrorFunction >
 
using StateErrorFunctiond_p = ::std::shared_ptr< StateErrorFunctiond >
 
using StateErrorFunctiond_u = ::std::unique_ptr< StateErrorFunctiond >
 
using StateErrorFunctiond_w = ::std::weak_ptr< StateErrorFunctiond >
 
using StateErrorFunctiond_const_p = ::std::shared_ptr< const StateErrorFunctiond >
 
using StateErrorFunctiond_const_u = ::std::unique_ptr< const StateErrorFunctiond >
 
using StateErrorFunctiond_const_w = ::std::weak_ptr< const StateErrorFunctiond >
 
using TrustRegionQR = TrustRegionQRT< float >
 
using TrustRegionQRd = TrustRegionQRT< double >
 
using TrustRegionQR_p = ::std::shared_ptr< TrustRegionQR >
 
using TrustRegionQR_u = ::std::unique_ptr< TrustRegionQR >
 
using TrustRegionQR_w = ::std::weak_ptr< TrustRegionQR >
 
using TrustRegionQR_const_p = ::std::shared_ptr< const TrustRegionQR >
 
using TrustRegionQR_const_u = ::std::unique_ptr< const TrustRegionQR >
 
using TrustRegionQR_const_w = ::std::weak_ptr< const TrustRegionQR >
 
using TrustRegionQRd_p = ::std::shared_ptr< TrustRegionQRd >
 
using TrustRegionQRd_u = ::std::unique_ptr< TrustRegionQRd >
 
using TrustRegionQRd_w = ::std::weak_ptr< TrustRegionQRd >
 
using TrustRegionQRd_const_p = ::std::shared_ptr< const TrustRegionQRd >
 
using TrustRegionQRd_const_u = ::std::unique_ptr< const TrustRegionQRd >
 
using TrustRegionQRd_const_w = ::std::weak_ptr< const TrustRegionQRd >
 
using VertexErrorFunction = VertexErrorFunctionT< float >
 
using VertexErrorFunctiond = VertexErrorFunctionT< double >
 
using VertexErrorFunction_p = ::std::shared_ptr< VertexErrorFunction >
 
using VertexErrorFunction_u = ::std::unique_ptr< VertexErrorFunction >
 
using VertexErrorFunction_w = ::std::weak_ptr< VertexErrorFunction >
 
using VertexErrorFunction_const_p = ::std::shared_ptr< const VertexErrorFunction >
 
using VertexErrorFunction_const_u = ::std::unique_ptr< const VertexErrorFunction >
 
using VertexErrorFunction_const_w = ::std::weak_ptr< const VertexErrorFunction >
 
using VertexErrorFunctiond_p = ::std::shared_ptr< VertexErrorFunctiond >
 
using VertexErrorFunctiond_u = ::std::unique_ptr< VertexErrorFunctiond >
 
using VertexErrorFunctiond_w = ::std::weak_ptr< VertexErrorFunctiond >
 
using VertexErrorFunctiond_const_p = ::std::shared_ptr< const VertexErrorFunctiond >
 
using VertexErrorFunctiond_const_u = ::std::unique_ptr< const VertexErrorFunctiond >
 
using VertexErrorFunctiond_const_w = ::std::weak_ptr< const VertexErrorFunctiond >
 
using VertexProjectionErrorFunction = VertexProjectionErrorFunctionT< float >
 
using VertexProjectionErrorFunctiond = VertexProjectionErrorFunctionT< double >
 
using VertexProjectionErrorFunction_p = ::std::shared_ptr< VertexProjectionErrorFunction >
 
using VertexProjectionErrorFunction_u = ::std::unique_ptr< VertexProjectionErrorFunction >
 
using VertexProjectionErrorFunction_w = ::std::weak_ptr< VertexProjectionErrorFunction >
 
using VertexProjectionErrorFunction_const_p = ::std::shared_ptr< const VertexProjectionErrorFunction >
 
using VertexProjectionErrorFunction_const_u = ::std::unique_ptr< const VertexProjectionErrorFunction >
 
using VertexProjectionErrorFunction_const_w = ::std::weak_ptr< const VertexProjectionErrorFunction >
 
using VertexProjectionErrorFunctiond_p = ::std::shared_ptr< VertexProjectionErrorFunctiond >
 
using VertexProjectionErrorFunctiond_u = ::std::unique_ptr< VertexProjectionErrorFunctiond >
 
using VertexProjectionErrorFunctiond_w = ::std::weak_ptr< VertexProjectionErrorFunctiond >
 
using VertexProjectionErrorFunctiond_const_p = ::std::shared_ptr< const VertexProjectionErrorFunctiond >
 
using VertexProjectionErrorFunctiond_const_u = ::std::unique_ptr< const VertexProjectionErrorFunctiond >
 
using VertexProjectionErrorFunctiond_const_w = ::std::weak_ptr< const VertexProjectionErrorFunctiond >
 
using VertexVertexDistanceErrorFunction = VertexVertexDistanceErrorFunctionT< float >
 
using VertexVertexDistanceErrorFunctiond = VertexVertexDistanceErrorFunctionT< double >
 
using VertexVertexDistanceErrorFunction_p = ::std::shared_ptr< VertexVertexDistanceErrorFunction >
 
using VertexVertexDistanceErrorFunction_u = ::std::unique_ptr< VertexVertexDistanceErrorFunction >
 
using VertexVertexDistanceErrorFunction_w = ::std::weak_ptr< VertexVertexDistanceErrorFunction >
 
using VertexVertexDistanceErrorFunction_const_p = ::std::shared_ptr< const VertexVertexDistanceErrorFunction >
 
using VertexVertexDistanceErrorFunction_const_u = ::std::unique_ptr< const VertexVertexDistanceErrorFunction >
 
using VertexVertexDistanceErrorFunction_const_w = ::std::weak_ptr< const VertexVertexDistanceErrorFunction >
 
using VertexVertexDistanceErrorFunctiond_p = ::std::shared_ptr< VertexVertexDistanceErrorFunctiond >
 
using VertexVertexDistanceErrorFunctiond_u = ::std::unique_ptr< VertexVertexDistanceErrorFunctiond >
 
using VertexVertexDistanceErrorFunctiond_w = ::std::weak_ptr< VertexVertexDistanceErrorFunctiond >
 
using VertexVertexDistanceErrorFunctiond_const_p = ::std::shared_ptr< const VertexVertexDistanceErrorFunctiond >
 
using VertexVertexDistanceErrorFunctiond_const_u = ::std::unique_ptr< const VertexVertexDistanceErrorFunctiond >
 
using VertexVertexDistanceErrorFunctiond_const_w = ::std::weak_ptr< const VertexVertexDistanceErrorFunctiond >
 
using MultiposeSolverOptions_p = ::std::shared_ptr< MultiposeSolverOptions >
 
using MultiposeSolverOptions_u = ::std::unique_ptr< MultiposeSolverOptions >
 
using MultiposeSolverOptions_w = ::std::weak_ptr< MultiposeSolverOptions >
 
using MultiposeSolverOptions_const_p = ::std::shared_ptr< const MultiposeSolverOptions >
 
using MultiposeSolverOptions_const_u = ::std::unique_ptr< const MultiposeSolverOptions >
 
using MultiposeSolverOptions_const_w = ::std::weak_ptr< const MultiposeSolverOptions >
 
using SequenceSolverOptions_p = ::std::shared_ptr< SequenceSolverOptions >
 
using SequenceSolverOptions_u = ::std::unique_ptr< SequenceSolverOptions >
 
using SequenceSolverOptions_w = ::std::weak_ptr< SequenceSolverOptions >
 
using SequenceSolverOptions_const_p = ::std::shared_ptr< const SequenceSolverOptions >
 
using SequenceSolverOptions_const_u = ::std::unique_ptr< const SequenceSolverOptions >
 
using SequenceSolverOptions_const_w = ::std::weak_ptr< const SequenceSolverOptions >
 
using AccelerationSequenceErrorFunction = AccelerationSequenceErrorFunctionT< float >
 
using AccelerationSequenceErrorFunctiond = AccelerationSequenceErrorFunctionT< double >
 
using AccelerationSequenceErrorFunction_p = ::std::shared_ptr< AccelerationSequenceErrorFunction >
 
using AccelerationSequenceErrorFunction_u = ::std::unique_ptr< AccelerationSequenceErrorFunction >
 
using AccelerationSequenceErrorFunction_w = ::std::weak_ptr< AccelerationSequenceErrorFunction >
 
using AccelerationSequenceErrorFunction_const_p = ::std::shared_ptr< const AccelerationSequenceErrorFunction >
 
using AccelerationSequenceErrorFunction_const_u = ::std::unique_ptr< const AccelerationSequenceErrorFunction >
 
using AccelerationSequenceErrorFunction_const_w = ::std::weak_ptr< const AccelerationSequenceErrorFunction >
 
using AccelerationSequenceErrorFunctiond_p = ::std::shared_ptr< AccelerationSequenceErrorFunctiond >
 
using AccelerationSequenceErrorFunctiond_u = ::std::unique_ptr< AccelerationSequenceErrorFunctiond >
 
using AccelerationSequenceErrorFunctiond_w = ::std::weak_ptr< AccelerationSequenceErrorFunctiond >
 
using AccelerationSequenceErrorFunctiond_const_p = ::std::shared_ptr< const AccelerationSequenceErrorFunctiond >
 
using AccelerationSequenceErrorFunctiond_const_u = ::std::unique_ptr< const AccelerationSequenceErrorFunctiond >
 
using AccelerationSequenceErrorFunctiond_const_w = ::std::weak_ptr< const AccelerationSequenceErrorFunctiond >
 
using FiniteDifferenceSequenceErrorFunction = FiniteDifferenceSequenceErrorFunctionT< float >
 
using FiniteDifferenceSequenceErrorFunctiond = FiniteDifferenceSequenceErrorFunctionT< double >
 
using FiniteDifferenceSequenceErrorFunction_p = ::std::shared_ptr< FiniteDifferenceSequenceErrorFunction >
 
using FiniteDifferenceSequenceErrorFunction_u = ::std::unique_ptr< FiniteDifferenceSequenceErrorFunction >
 
using FiniteDifferenceSequenceErrorFunction_w = ::std::weak_ptr< FiniteDifferenceSequenceErrorFunction >
 
using FiniteDifferenceSequenceErrorFunction_const_p = ::std::shared_ptr< const FiniteDifferenceSequenceErrorFunction >
 
using FiniteDifferenceSequenceErrorFunction_const_u = ::std::unique_ptr< const FiniteDifferenceSequenceErrorFunction >
 
using FiniteDifferenceSequenceErrorFunction_const_w = ::std::weak_ptr< const FiniteDifferenceSequenceErrorFunction >
 
using FiniteDifferenceSequenceErrorFunctiond_p = ::std::shared_ptr< FiniteDifferenceSequenceErrorFunctiond >
 
using FiniteDifferenceSequenceErrorFunctiond_u = ::std::unique_ptr< FiniteDifferenceSequenceErrorFunctiond >
 
using FiniteDifferenceSequenceErrorFunctiond_w = ::std::weak_ptr< FiniteDifferenceSequenceErrorFunctiond >
 
using FiniteDifferenceSequenceErrorFunctiond_const_p = ::std::shared_ptr< const FiniteDifferenceSequenceErrorFunctiond >
 
using FiniteDifferenceSequenceErrorFunctiond_const_u = ::std::unique_ptr< const FiniteDifferenceSequenceErrorFunctiond >
 
using FiniteDifferenceSequenceErrorFunctiond_const_w = ::std::weak_ptr< const FiniteDifferenceSequenceErrorFunctiond >
 
using JerkSequenceErrorFunction = JerkSequenceErrorFunctionT< float >
 
using JerkSequenceErrorFunctiond = JerkSequenceErrorFunctionT< double >
 
using JerkSequenceErrorFunction_p = ::std::shared_ptr< JerkSequenceErrorFunction >
 
using JerkSequenceErrorFunction_u = ::std::unique_ptr< JerkSequenceErrorFunction >
 
using JerkSequenceErrorFunction_w = ::std::weak_ptr< JerkSequenceErrorFunction >
 
using JerkSequenceErrorFunction_const_p = ::std::shared_ptr< const JerkSequenceErrorFunction >
 
using JerkSequenceErrorFunction_const_u = ::std::unique_ptr< const JerkSequenceErrorFunction >
 
using JerkSequenceErrorFunction_const_w = ::std::weak_ptr< const JerkSequenceErrorFunction >
 
using JerkSequenceErrorFunctiond_p = ::std::shared_ptr< JerkSequenceErrorFunctiond >
 
using JerkSequenceErrorFunctiond_u = ::std::unique_ptr< JerkSequenceErrorFunctiond >
 
using JerkSequenceErrorFunctiond_w = ::std::weak_ptr< JerkSequenceErrorFunctiond >
 
using JerkSequenceErrorFunctiond_const_p = ::std::shared_ptr< const JerkSequenceErrorFunctiond >
 
using JerkSequenceErrorFunctiond_const_u = ::std::unique_ptr< const JerkSequenceErrorFunctiond >
 
using JerkSequenceErrorFunctiond_const_w = ::std::weak_ptr< const JerkSequenceErrorFunctiond >
 
using SequenceErrorFunction = SequenceErrorFunctionT< float >
 
using SequenceErrorFunctiond = SequenceErrorFunctionT< double >
 
using SequenceErrorFunction_p = ::std::shared_ptr< SequenceErrorFunction >
 
using SequenceErrorFunction_u = ::std::unique_ptr< SequenceErrorFunction >
 
using SequenceErrorFunction_w = ::std::weak_ptr< SequenceErrorFunction >
 
using SequenceErrorFunction_const_p = ::std::shared_ptr< const SequenceErrorFunction >
 
using SequenceErrorFunction_const_u = ::std::unique_ptr< const SequenceErrorFunction >
 
using SequenceErrorFunction_const_w = ::std::weak_ptr< const SequenceErrorFunction >
 
using SequenceErrorFunctiond_p = ::std::shared_ptr< SequenceErrorFunctiond >
 
using SequenceErrorFunctiond_u = ::std::unique_ptr< SequenceErrorFunctiond >
 
using SequenceErrorFunctiond_w = ::std::weak_ptr< SequenceErrorFunctiond >
 
using SequenceErrorFunctiond_const_p = ::std::shared_ptr< const SequenceErrorFunctiond >
 
using SequenceErrorFunctiond_const_u = ::std::unique_ptr< const SequenceErrorFunctiond >
 
using SequenceErrorFunctiond_const_w = ::std::weak_ptr< const SequenceErrorFunctiond >
 
using ModelParametersSequenceErrorFunction = ModelParametersSequenceErrorFunctionT< float >
 
using ModelParametersSequenceErrorFunctiond = ModelParametersSequenceErrorFunctionT< double >
 
using ModelParametersSequenceErrorFunction_p = ::std::shared_ptr< ModelParametersSequenceErrorFunction >
 
using ModelParametersSequenceErrorFunction_u = ::std::unique_ptr< ModelParametersSequenceErrorFunction >
 
using ModelParametersSequenceErrorFunction_w = ::std::weak_ptr< ModelParametersSequenceErrorFunction >
 
using ModelParametersSequenceErrorFunction_const_p = ::std::shared_ptr< const ModelParametersSequenceErrorFunction >
 
using ModelParametersSequenceErrorFunction_const_u = ::std::unique_ptr< const ModelParametersSequenceErrorFunction >
 
using ModelParametersSequenceErrorFunction_const_w = ::std::weak_ptr< const ModelParametersSequenceErrorFunction >
 
using ModelParametersSequenceErrorFunctiond_p = ::std::shared_ptr< ModelParametersSequenceErrorFunctiond >
 
using ModelParametersSequenceErrorFunctiond_u = ::std::unique_ptr< ModelParametersSequenceErrorFunctiond >
 
using ModelParametersSequenceErrorFunctiond_w = ::std::weak_ptr< ModelParametersSequenceErrorFunctiond >
 
using ModelParametersSequenceErrorFunctiond_const_p = ::std::shared_ptr< const ModelParametersSequenceErrorFunctiond >
 
using ModelParametersSequenceErrorFunctiond_const_u = ::std::unique_ptr< const ModelParametersSequenceErrorFunctiond >
 
using ModelParametersSequenceErrorFunctiond_const_w = ::std::weak_ptr< const ModelParametersSequenceErrorFunctiond >
 
using MultiposeSolver = MultiposeSolverT< float >
 
using MultiposeSolverd = MultiposeSolverT< double >
 
using MultiposeSolver_p = ::std::shared_ptr< MultiposeSolver >
 
using MultiposeSolver_u = ::std::unique_ptr< MultiposeSolver >
 
using MultiposeSolver_w = ::std::weak_ptr< MultiposeSolver >
 
using MultiposeSolver_const_p = ::std::shared_ptr< const MultiposeSolver >
 
using MultiposeSolver_const_u = ::std::unique_ptr< const MultiposeSolver >
 
using MultiposeSolver_const_w = ::std::weak_ptr< const MultiposeSolver >
 
using MultiposeSolverd_p = ::std::shared_ptr< MultiposeSolverd >
 
using MultiposeSolverd_u = ::std::unique_ptr< MultiposeSolverd >
 
using MultiposeSolverd_w = ::std::weak_ptr< MultiposeSolverd >
 
using MultiposeSolverd_const_p = ::std::shared_ptr< const MultiposeSolverd >
 
using MultiposeSolverd_const_u = ::std::unique_ptr< const MultiposeSolverd >
 
using MultiposeSolverd_const_w = ::std::weak_ptr< const MultiposeSolverd >
 
using MultiposeSolverFunction = MultiposeSolverFunctionT< float >
 
using MultiposeSolverFunctiond = MultiposeSolverFunctionT< double >
 
using MultiposeSolverFunction_p = ::std::shared_ptr< MultiposeSolverFunction >
 
using MultiposeSolverFunction_u = ::std::unique_ptr< MultiposeSolverFunction >
 
using MultiposeSolverFunction_w = ::std::weak_ptr< MultiposeSolverFunction >
 
using MultiposeSolverFunction_const_p = ::std::shared_ptr< const MultiposeSolverFunction >
 
using MultiposeSolverFunction_const_u = ::std::unique_ptr< const MultiposeSolverFunction >
 
using MultiposeSolverFunction_const_w = ::std::weak_ptr< const MultiposeSolverFunction >
 
using MultiposeSolverFunctiond_p = ::std::shared_ptr< MultiposeSolverFunctiond >
 
using MultiposeSolverFunctiond_u = ::std::unique_ptr< MultiposeSolverFunctiond >
 
using MultiposeSolverFunctiond_w = ::std::weak_ptr< MultiposeSolverFunctiond >
 
using MultiposeSolverFunctiond_const_p = ::std::shared_ptr< const MultiposeSolverFunctiond >
 
using MultiposeSolverFunctiond_const_u = ::std::unique_ptr< const MultiposeSolverFunctiond >
 
using MultiposeSolverFunctiond_const_w = ::std::weak_ptr< const MultiposeSolverFunctiond >
 
using SequenceSolver = SequenceSolverT< float >
 
using SequenceSolverd = SequenceSolverT< double >
 
using SequenceSolver_p = ::std::shared_ptr< SequenceSolver >
 
using SequenceSolver_u = ::std::unique_ptr< SequenceSolver >
 
using SequenceSolver_w = ::std::weak_ptr< SequenceSolver >
 
using SequenceSolver_const_p = ::std::shared_ptr< const SequenceSolver >
 
using SequenceSolver_const_u = ::std::unique_ptr< const SequenceSolver >
 
using SequenceSolver_const_w = ::std::weak_ptr< const SequenceSolver >
 
using SequenceSolverd_p = ::std::shared_ptr< SequenceSolverd >
 
using SequenceSolverd_u = ::std::unique_ptr< SequenceSolverd >
 
using SequenceSolverd_w = ::std::weak_ptr< SequenceSolverd >
 
using SequenceSolverd_const_p = ::std::shared_ptr< const SequenceSolverd >
 
using SequenceSolverd_const_u = ::std::unique_ptr< const SequenceSolverd >
 
using SequenceSolverd_const_w = ::std::weak_ptr< const SequenceSolverd >
 
using SequenceSolverFunction = SequenceSolverFunctionT< float >
 
using SequenceSolverFunctiond = SequenceSolverFunctionT< double >
 
using SequenceSolverFunction_p = ::std::shared_ptr< SequenceSolverFunction >
 
using SequenceSolverFunction_u = ::std::unique_ptr< SequenceSolverFunction >
 
using SequenceSolverFunction_w = ::std::weak_ptr< SequenceSolverFunction >
 
using SequenceSolverFunction_const_p = ::std::shared_ptr< const SequenceSolverFunction >
 
using SequenceSolverFunction_const_u = ::std::unique_ptr< const SequenceSolverFunction >
 
using SequenceSolverFunction_const_w = ::std::weak_ptr< const SequenceSolverFunction >
 
using SequenceSolverFunctiond_p = ::std::shared_ptr< SequenceSolverFunctiond >
 
using SequenceSolverFunctiond_u = ::std::unique_ptr< SequenceSolverFunctiond >
 
using SequenceSolverFunctiond_w = ::std::weak_ptr< SequenceSolverFunctiond >
 
using SequenceSolverFunctiond_const_p = ::std::shared_ptr< const SequenceSolverFunctiond >
 
using SequenceSolverFunctiond_const_u = ::std::unique_ptr< const SequenceSolverFunctiond >
 
using SequenceSolverFunctiond_const_w = ::std::weak_ptr< const SequenceSolverFunctiond >
 
using StateSequenceErrorFunction = StateSequenceErrorFunctionT< float >
 
using StateSequenceErrorFunctiond = StateSequenceErrorFunctionT< double >
 
using StateSequenceErrorFunction_p = ::std::shared_ptr< StateSequenceErrorFunction >
 
using StateSequenceErrorFunction_u = ::std::unique_ptr< StateSequenceErrorFunction >
 
using StateSequenceErrorFunction_w = ::std::weak_ptr< StateSequenceErrorFunction >
 
using StateSequenceErrorFunction_const_p = ::std::shared_ptr< const StateSequenceErrorFunction >
 
using StateSequenceErrorFunction_const_u = ::std::unique_ptr< const StateSequenceErrorFunction >
 
using StateSequenceErrorFunction_const_w = ::std::weak_ptr< const StateSequenceErrorFunction >
 
using StateSequenceErrorFunctiond_p = ::std::shared_ptr< StateSequenceErrorFunctiond >
 
using StateSequenceErrorFunctiond_u = ::std::unique_ptr< StateSequenceErrorFunctiond >
 
using StateSequenceErrorFunctiond_w = ::std::weak_ptr< StateSequenceErrorFunctiond >
 
using StateSequenceErrorFunctiond_const_p = ::std::shared_ptr< const StateSequenceErrorFunctiond >
 
using StateSequenceErrorFunctiond_const_u = ::std::unique_ptr< const StateSequenceErrorFunctiond >
 
using StateSequenceErrorFunctiond_const_w = ::std::weak_ptr< const StateSequenceErrorFunctiond >
 
using VelocityMagnitudeSequenceErrorFunction = VelocityMagnitudeSequenceErrorFunctionT< float >
 
using VelocityMagnitudeSequenceErrorFunctiond = VelocityMagnitudeSequenceErrorFunctionT< double >
 
using VelocityMagnitudeSequenceErrorFunction_p = ::std::shared_ptr< VelocityMagnitudeSequenceErrorFunction >
 
using VelocityMagnitudeSequenceErrorFunction_u = ::std::unique_ptr< VelocityMagnitudeSequenceErrorFunction >
 
using VelocityMagnitudeSequenceErrorFunction_w = ::std::weak_ptr< VelocityMagnitudeSequenceErrorFunction >
 
using VelocityMagnitudeSequenceErrorFunction_const_p = ::std::shared_ptr< const VelocityMagnitudeSequenceErrorFunction >
 
using VelocityMagnitudeSequenceErrorFunction_const_u = ::std::unique_ptr< const VelocityMagnitudeSequenceErrorFunction >
 
using VelocityMagnitudeSequenceErrorFunction_const_w = ::std::weak_ptr< const VelocityMagnitudeSequenceErrorFunction >
 
using VelocityMagnitudeSequenceErrorFunctiond_p = ::std::shared_ptr< VelocityMagnitudeSequenceErrorFunctiond >
 
using VelocityMagnitudeSequenceErrorFunctiond_u = ::std::unique_ptr< VelocityMagnitudeSequenceErrorFunctiond >
 
using VelocityMagnitudeSequenceErrorFunctiond_w = ::std::weak_ptr< VelocityMagnitudeSequenceErrorFunctiond >
 
using VelocityMagnitudeSequenceErrorFunctiond_const_p = ::std::shared_ptr< const VelocityMagnitudeSequenceErrorFunctiond >
 
using VelocityMagnitudeSequenceErrorFunctiond_const_u = ::std::unique_ptr< const VelocityMagnitudeSequenceErrorFunctiond >
 
using VelocityMagnitudeSequenceErrorFunctiond_const_w = ::std::weak_ptr< const VelocityMagnitudeSequenceErrorFunctiond >
 
using VertexSequenceErrorFunction = VertexSequenceErrorFunctionT< float >
 
using VertexSequenceErrorFunctiond = VertexSequenceErrorFunctionT< double >
 
using VertexSequenceErrorFunction_p = ::std::shared_ptr< VertexSequenceErrorFunction >
 
using VertexSequenceErrorFunction_u = ::std::unique_ptr< VertexSequenceErrorFunction >
 
using VertexSequenceErrorFunction_w = ::std::weak_ptr< VertexSequenceErrorFunction >
 
using VertexSequenceErrorFunction_const_p = ::std::shared_ptr< const VertexSequenceErrorFunction >
 
using VertexSequenceErrorFunction_const_u = ::std::unique_ptr< const VertexSequenceErrorFunction >
 
using VertexSequenceErrorFunction_const_w = ::std::weak_ptr< const VertexSequenceErrorFunction >
 
using VertexSequenceErrorFunctiond_p = ::std::shared_ptr< VertexSequenceErrorFunctiond >
 
using VertexSequenceErrorFunctiond_u = ::std::unique_ptr< VertexSequenceErrorFunctiond >
 
using VertexSequenceErrorFunctiond_w = ::std::weak_ptr< VertexSequenceErrorFunctiond >
 
using VertexSequenceErrorFunctiond_const_p = ::std::shared_ptr< const VertexSequenceErrorFunctiond >
 
using VertexSequenceErrorFunctiond_const_u = ::std::unique_ptr< const VertexSequenceErrorFunctiond >
 
using VertexSequenceErrorFunctiond_const_w = ::std::weak_ptr< const VertexSequenceErrorFunctiond >
 
using ErrorFunctionDerivatives = ErrorFunctionDerivativesT< float >
 
using ErrorFunctionDerivativesd = ErrorFunctionDerivativesT< double >
 
using ErrorFunctionDerivatives_p = ::std::shared_ptr< ErrorFunctionDerivatives >
 
using ErrorFunctionDerivatives_u = ::std::unique_ptr< ErrorFunctionDerivatives >
 
using ErrorFunctionDerivatives_w = ::std::weak_ptr< ErrorFunctionDerivatives >
 
using ErrorFunctionDerivatives_const_p = ::std::shared_ptr< const ErrorFunctionDerivatives >
 
using ErrorFunctionDerivatives_const_u = ::std::unique_ptr< const ErrorFunctionDerivatives >
 
using ErrorFunctionDerivatives_const_w = ::std::weak_ptr< const ErrorFunctionDerivatives >
 
using ErrorFunctionDerivativesd_p = ::std::shared_ptr< ErrorFunctionDerivativesd >
 
using ErrorFunctionDerivativesd_u = ::std::unique_ptr< ErrorFunctionDerivativesd >
 
using ErrorFunctionDerivativesd_w = ::std::weak_ptr< ErrorFunctionDerivativesd >
 
using ErrorFunctionDerivativesd_const_p = ::std::shared_ptr< const ErrorFunctionDerivativesd >
 
using ErrorFunctionDerivativesd_const_u = ::std::unique_ptr< const ErrorFunctionDerivativesd >
 
using ErrorFunctionDerivativesd_const_w = ::std::weak_ptr< const ErrorFunctionDerivativesd >
 
using OrientationConstraint = OrientationConstraintT< float >
 
using OrientationConstraintd = OrientationConstraintT< double >
 
using OrientationConstraint_p = ::std::shared_ptr< OrientationConstraint >
 
using OrientationConstraint_u = ::std::unique_ptr< OrientationConstraint >
 
using OrientationConstraint_w = ::std::weak_ptr< OrientationConstraint >
 
using OrientationConstraint_const_p = ::std::shared_ptr< const OrientationConstraint >
 
using OrientationConstraint_const_u = ::std::unique_ptr< const OrientationConstraint >
 
using OrientationConstraint_const_w = ::std::weak_ptr< const OrientationConstraint >
 
using OrientationConstraintd_p = ::std::shared_ptr< OrientationConstraintd >
 
using OrientationConstraintd_u = ::std::unique_ptr< OrientationConstraintd >
 
using OrientationConstraintd_w = ::std::weak_ptr< OrientationConstraintd >
 
using OrientationConstraintd_const_p = ::std::shared_ptr< const OrientationConstraintd >
 
using OrientationConstraintd_const_u = ::std::unique_ptr< const OrientationConstraintd >
 
using OrientationConstraintd_const_w = ::std::weak_ptr< const OrientationConstraintd >
 
using OrientationConstraintState = OrientationConstraintStateT< float >
 
using OrientationConstraintStated = OrientationConstraintStateT< double >
 
using OrientationConstraintState_p = ::std::shared_ptr< OrientationConstraintState >
 
using OrientationConstraintState_u = ::std::unique_ptr< OrientationConstraintState >
 
using OrientationConstraintState_w = ::std::weak_ptr< OrientationConstraintState >
 
using OrientationConstraintState_const_p = ::std::shared_ptr< const OrientationConstraintState >
 
using OrientationConstraintState_const_u = ::std::unique_ptr< const OrientationConstraintState >
 
using OrientationConstraintState_const_w = ::std::weak_ptr< const OrientationConstraintState >
 
using OrientationConstraintStated_p = ::std::shared_ptr< OrientationConstraintStated >
 
using OrientationConstraintStated_u = ::std::unique_ptr< OrientationConstraintStated >
 
using OrientationConstraintStated_w = ::std::weak_ptr< OrientationConstraintStated >
 
using OrientationConstraintStated_const_p = ::std::shared_ptr< const OrientationConstraintStated >
 
using OrientationConstraintStated_const_u = ::std::unique_ptr< const OrientationConstraintStated >
 
using OrientationConstraintStated_const_w = ::std::weak_ptr< const OrientationConstraintStated >
 
using PositionConstraint = PositionConstraintT< float >
 
using PositionConstraintd = PositionConstraintT< double >
 
using PositionConstraint_p = ::std::shared_ptr< PositionConstraint >
 
using PositionConstraint_u = ::std::unique_ptr< PositionConstraint >
 
using PositionConstraint_w = ::std::weak_ptr< PositionConstraint >
 
using PositionConstraint_const_p = ::std::shared_ptr< const PositionConstraint >
 
using PositionConstraint_const_u = ::std::unique_ptr< const PositionConstraint >
 
using PositionConstraint_const_w = ::std::weak_ptr< const PositionConstraint >
 
using PositionConstraintd_p = ::std::shared_ptr< PositionConstraintd >
 
using PositionConstraintd_u = ::std::unique_ptr< PositionConstraintd >
 
using PositionConstraintd_w = ::std::weak_ptr< PositionConstraintd >
 
using PositionConstraintd_const_p = ::std::shared_ptr< const PositionConstraintd >
 
using PositionConstraintd_const_u = ::std::unique_ptr< const PositionConstraintd >
 
using PositionConstraintd_const_w = ::std::weak_ptr< const PositionConstraintd >
 
using PositionConstraintState = PositionConstraintStateT< float >
 
using PositionConstraintStated = PositionConstraintStateT< double >
 
using PositionConstraintState_p = ::std::shared_ptr< PositionConstraintState >
 
using PositionConstraintState_u = ::std::unique_ptr< PositionConstraintState >
 
using PositionConstraintState_w = ::std::weak_ptr< PositionConstraintState >
 
using PositionConstraintState_const_p = ::std::shared_ptr< const PositionConstraintState >
 
using PositionConstraintState_const_u = ::std::unique_ptr< const PositionConstraintState >
 
using PositionConstraintState_const_w = ::std::weak_ptr< const PositionConstraintState >
 
using PositionConstraintStated_p = ::std::shared_ptr< PositionConstraintStated >
 
using PositionConstraintStated_u = ::std::unique_ptr< PositionConstraintStated >
 
using PositionConstraintStated_w = ::std::weak_ptr< PositionConstraintStated >
 
using PositionConstraintStated_const_p = ::std::shared_ptr< const PositionConstraintStated >
 
using PositionConstraintStated_const_u = ::std::unique_ptr< const PositionConstraintStated >
 
using PositionConstraintStated_const_w = ::std::weak_ptr< const PositionConstraintStated >
 
using FullyDifferentiableDistanceErrorFunction = FullyDifferentiableDistanceErrorFunctionT< float >
 
using FullyDifferentiableDistanceErrorFunctiond = FullyDifferentiableDistanceErrorFunctionT< double >
 
using FullyDifferentiableDistanceErrorFunction_p = ::std::shared_ptr< FullyDifferentiableDistanceErrorFunction >
 
using FullyDifferentiableDistanceErrorFunction_u = ::std::unique_ptr< FullyDifferentiableDistanceErrorFunction >
 
using FullyDifferentiableDistanceErrorFunction_w = ::std::weak_ptr< FullyDifferentiableDistanceErrorFunction >
 
using FullyDifferentiableDistanceErrorFunction_const_p = ::std::shared_ptr< const FullyDifferentiableDistanceErrorFunction >
 
using FullyDifferentiableDistanceErrorFunction_const_u = ::std::unique_ptr< const FullyDifferentiableDistanceErrorFunction >
 
using FullyDifferentiableDistanceErrorFunction_const_w = ::std::weak_ptr< const FullyDifferentiableDistanceErrorFunction >
 
using FullyDifferentiableDistanceErrorFunctiond_p = ::std::shared_ptr< FullyDifferentiableDistanceErrorFunctiond >
 
using FullyDifferentiableDistanceErrorFunctiond_u = ::std::unique_ptr< FullyDifferentiableDistanceErrorFunctiond >
 
using FullyDifferentiableDistanceErrorFunctiond_w = ::std::weak_ptr< FullyDifferentiableDistanceErrorFunctiond >
 
using FullyDifferentiableDistanceErrorFunctiond_const_p = ::std::shared_ptr< const FullyDifferentiableDistanceErrorFunctiond >
 
using FullyDifferentiableDistanceErrorFunctiond_const_u = ::std::unique_ptr< const FullyDifferentiableDistanceErrorFunctiond >
 
using FullyDifferentiableDistanceErrorFunctiond_const_w = ::std::weak_ptr< const FullyDifferentiableDistanceErrorFunctiond >
 
using FullyDifferentiableMotionErrorFunction = FullyDifferentiableMotionErrorFunctionT< float >
 
using FullyDifferentiableMotionErrorFunctiond = FullyDifferentiableMotionErrorFunctionT< double >
 
using FullyDifferentiableMotionErrorFunction_p = ::std::shared_ptr< FullyDifferentiableMotionErrorFunction >
 
using FullyDifferentiableMotionErrorFunction_u = ::std::unique_ptr< FullyDifferentiableMotionErrorFunction >
 
using FullyDifferentiableMotionErrorFunction_w = ::std::weak_ptr< FullyDifferentiableMotionErrorFunction >
 
using FullyDifferentiableMotionErrorFunction_const_p = ::std::shared_ptr< const FullyDifferentiableMotionErrorFunction >
 
using FullyDifferentiableMotionErrorFunction_const_u = ::std::unique_ptr< const FullyDifferentiableMotionErrorFunction >
 
using FullyDifferentiableMotionErrorFunction_const_w = ::std::weak_ptr< const FullyDifferentiableMotionErrorFunction >
 
using FullyDifferentiableMotionErrorFunctiond_p = ::std::shared_ptr< FullyDifferentiableMotionErrorFunctiond >
 
using FullyDifferentiableMotionErrorFunctiond_u = ::std::unique_ptr< FullyDifferentiableMotionErrorFunctiond >
 
using FullyDifferentiableMotionErrorFunctiond_w = ::std::weak_ptr< FullyDifferentiableMotionErrorFunctiond >
 
using FullyDifferentiableMotionErrorFunctiond_const_p = ::std::shared_ptr< const FullyDifferentiableMotionErrorFunctiond >
 
using FullyDifferentiableMotionErrorFunctiond_const_u = ::std::unique_ptr< const FullyDifferentiableMotionErrorFunctiond >
 
using FullyDifferentiableMotionErrorFunctiond_const_w = ::std::weak_ptr< const FullyDifferentiableMotionErrorFunctiond >
 
using FullyDifferentiableOrientationErrorFunction = FullyDifferentiableOrientationErrorFunctionT< float >
 
using FullyDifferentiableOrientationErrorFunctiond = FullyDifferentiableOrientationErrorFunctionT< double >
 
using FullyDifferentiableOrientationErrorFunction_p = ::std::shared_ptr< FullyDifferentiableOrientationErrorFunction >
 
using FullyDifferentiableOrientationErrorFunction_u = ::std::unique_ptr< FullyDifferentiableOrientationErrorFunction >
 
using FullyDifferentiableOrientationErrorFunction_w = ::std::weak_ptr< FullyDifferentiableOrientationErrorFunction >
 
using FullyDifferentiableOrientationErrorFunction_const_p = ::std::shared_ptr< const FullyDifferentiableOrientationErrorFunction >
 
using FullyDifferentiableOrientationErrorFunction_const_u = ::std::unique_ptr< const FullyDifferentiableOrientationErrorFunction >
 
using FullyDifferentiableOrientationErrorFunction_const_w = ::std::weak_ptr< const FullyDifferentiableOrientationErrorFunction >
 
using FullyDifferentiableOrientationErrorFunctiond_p = ::std::shared_ptr< FullyDifferentiableOrientationErrorFunctiond >
 
using FullyDifferentiableOrientationErrorFunctiond_u = ::std::unique_ptr< FullyDifferentiableOrientationErrorFunctiond >
 
using FullyDifferentiableOrientationErrorFunctiond_w = ::std::weak_ptr< FullyDifferentiableOrientationErrorFunctiond >
 
using FullyDifferentiableOrientationErrorFunctiond_const_p = ::std::shared_ptr< const FullyDifferentiableOrientationErrorFunctiond >
 
using FullyDifferentiableOrientationErrorFunctiond_const_u = ::std::unique_ptr< const FullyDifferentiableOrientationErrorFunctiond >
 
using FullyDifferentiableOrientationErrorFunctiond_const_w = ::std::weak_ptr< const FullyDifferentiableOrientationErrorFunctiond >
 
using FullyDifferentiablePosePriorErrorFunction = FullyDifferentiablePosePriorErrorFunctionT< float >
 
using FullyDifferentiablePosePriorErrorFunctiond = FullyDifferentiablePosePriorErrorFunctionT< double >
 
using FullyDifferentiablePosePriorErrorFunction_p = ::std::shared_ptr< FullyDifferentiablePosePriorErrorFunction >
 
using FullyDifferentiablePosePriorErrorFunction_u = ::std::unique_ptr< FullyDifferentiablePosePriorErrorFunction >
 
using FullyDifferentiablePosePriorErrorFunction_w = ::std::weak_ptr< FullyDifferentiablePosePriorErrorFunction >
 
using FullyDifferentiablePosePriorErrorFunction_const_p = ::std::shared_ptr< const FullyDifferentiablePosePriorErrorFunction >
 
using FullyDifferentiablePosePriorErrorFunction_const_u = ::std::unique_ptr< const FullyDifferentiablePosePriorErrorFunction >
 
using FullyDifferentiablePosePriorErrorFunction_const_w = ::std::weak_ptr< const FullyDifferentiablePosePriorErrorFunction >
 
using FullyDifferentiablePosePriorErrorFunctiond_p = ::std::shared_ptr< FullyDifferentiablePosePriorErrorFunctiond >
 
using FullyDifferentiablePosePriorErrorFunctiond_u = ::std::unique_ptr< FullyDifferentiablePosePriorErrorFunctiond >
 
using FullyDifferentiablePosePriorErrorFunctiond_w = ::std::weak_ptr< FullyDifferentiablePosePriorErrorFunctiond >
 
using FullyDifferentiablePosePriorErrorFunctiond_const_p = ::std::shared_ptr< const FullyDifferentiablePosePriorErrorFunctiond >
 
using FullyDifferentiablePosePriorErrorFunctiond_const_u = ::std::unique_ptr< const FullyDifferentiablePosePriorErrorFunctiond >
 
using FullyDifferentiablePosePriorErrorFunctiond_const_w = ::std::weak_ptr< const FullyDifferentiablePosePriorErrorFunctiond >
 
using FullyDifferentiablePositionErrorFunction = FullyDifferentiablePositionErrorFunctionT< float >
 
using FullyDifferentiablePositionErrorFunctiond = FullyDifferentiablePositionErrorFunctionT< double >
 
using FullyDifferentiablePositionErrorFunction_p = ::std::shared_ptr< FullyDifferentiablePositionErrorFunction >
 
using FullyDifferentiablePositionErrorFunction_u = ::std::unique_ptr< FullyDifferentiablePositionErrorFunction >
 
using FullyDifferentiablePositionErrorFunction_w = ::std::weak_ptr< FullyDifferentiablePositionErrorFunction >
 
using FullyDifferentiablePositionErrorFunction_const_p = ::std::shared_ptr< const FullyDifferentiablePositionErrorFunction >
 
using FullyDifferentiablePositionErrorFunction_const_u = ::std::unique_ptr< const FullyDifferentiablePositionErrorFunction >
 
using FullyDifferentiablePositionErrorFunction_const_w = ::std::weak_ptr< const FullyDifferentiablePositionErrorFunction >
 
using FullyDifferentiablePositionErrorFunctiond_p = ::std::shared_ptr< FullyDifferentiablePositionErrorFunctiond >
 
using FullyDifferentiablePositionErrorFunctiond_u = ::std::unique_ptr< FullyDifferentiablePositionErrorFunctiond >
 
using FullyDifferentiablePositionErrorFunctiond_w = ::std::weak_ptr< FullyDifferentiablePositionErrorFunctiond >
 
using FullyDifferentiablePositionErrorFunctiond_const_p = ::std::shared_ptr< const FullyDifferentiablePositionErrorFunctiond >
 
using FullyDifferentiablePositionErrorFunctiond_const_u = ::std::unique_ptr< const FullyDifferentiablePositionErrorFunctiond >
 
using FullyDifferentiablePositionErrorFunctiond_const_w = ::std::weak_ptr< const FullyDifferentiablePositionErrorFunctiond >
 
using FullyDifferentiableProjectionErrorFunction = FullyDifferentiableProjectionErrorFunctionT< float >
 
using FullyDifferentiableProjectionErrorFunctiond = FullyDifferentiableProjectionErrorFunctionT< double >
 
using FullyDifferentiableProjectionErrorFunction_p = ::std::shared_ptr< FullyDifferentiableProjectionErrorFunction >
 
using FullyDifferentiableProjectionErrorFunction_u = ::std::unique_ptr< FullyDifferentiableProjectionErrorFunction >
 
using FullyDifferentiableProjectionErrorFunction_w = ::std::weak_ptr< FullyDifferentiableProjectionErrorFunction >
 
using FullyDifferentiableProjectionErrorFunction_const_p = ::std::shared_ptr< const FullyDifferentiableProjectionErrorFunction >
 
using FullyDifferentiableProjectionErrorFunction_const_u = ::std::unique_ptr< const FullyDifferentiableProjectionErrorFunction >
 
using FullyDifferentiableProjectionErrorFunction_const_w = ::std::weak_ptr< const FullyDifferentiableProjectionErrorFunction >
 
using FullyDifferentiableProjectionErrorFunctiond_p = ::std::shared_ptr< FullyDifferentiableProjectionErrorFunctiond >
 
using FullyDifferentiableProjectionErrorFunctiond_u = ::std::unique_ptr< FullyDifferentiableProjectionErrorFunctiond >
 
using FullyDifferentiableProjectionErrorFunctiond_w = ::std::weak_ptr< FullyDifferentiableProjectionErrorFunctiond >
 
using FullyDifferentiableProjectionErrorFunctiond_const_p = ::std::shared_ptr< const FullyDifferentiableProjectionErrorFunctiond >
 
using FullyDifferentiableProjectionErrorFunctiond_const_u = ::std::unique_ptr< const FullyDifferentiableProjectionErrorFunctiond >
 
using FullyDifferentiableProjectionErrorFunctiond_const_w = ::std::weak_ptr< const FullyDifferentiableProjectionErrorFunctiond >
 
using FullyDifferentiableSkeletonErrorFunction = FullyDifferentiableSkeletonErrorFunctionT< float >
 
using FullyDifferentiableSkeletonErrorFunctiond = FullyDifferentiableSkeletonErrorFunctionT< double >
 
using FullyDifferentiableSkeletonErrorFunction_p = ::std::shared_ptr< FullyDifferentiableSkeletonErrorFunction >
 
using FullyDifferentiableSkeletonErrorFunction_u = ::std::unique_ptr< FullyDifferentiableSkeletonErrorFunction >
 
using FullyDifferentiableSkeletonErrorFunction_w = ::std::weak_ptr< FullyDifferentiableSkeletonErrorFunction >
 
using FullyDifferentiableSkeletonErrorFunction_const_p = ::std::shared_ptr< const FullyDifferentiableSkeletonErrorFunction >
 
using FullyDifferentiableSkeletonErrorFunction_const_u = ::std::unique_ptr< const FullyDifferentiableSkeletonErrorFunction >
 
using FullyDifferentiableSkeletonErrorFunction_const_w = ::std::weak_ptr< const FullyDifferentiableSkeletonErrorFunction >
 
using FullyDifferentiableSkeletonErrorFunctiond_p = ::std::shared_ptr< FullyDifferentiableSkeletonErrorFunctiond >
 
using FullyDifferentiableSkeletonErrorFunctiond_u = ::std::unique_ptr< FullyDifferentiableSkeletonErrorFunctiond >
 
using FullyDifferentiableSkeletonErrorFunctiond_w = ::std::weak_ptr< FullyDifferentiableSkeletonErrorFunctiond >
 
using FullyDifferentiableSkeletonErrorFunctiond_const_p = ::std::shared_ptr< const FullyDifferentiableSkeletonErrorFunctiond >
 
using FullyDifferentiableSkeletonErrorFunctiond_const_u = ::std::unique_ptr< const FullyDifferentiableSkeletonErrorFunctiond >
 
using FullyDifferentiableSkeletonErrorFunctiond_const_w = ::std::weak_ptr< const FullyDifferentiableSkeletonErrorFunctiond >
 
using FullyDifferentiableStateErrorFunction = FullyDifferentiableStateErrorFunctionT< float >
 
using FullyDifferentiableStateErrorFunctiond = FullyDifferentiableStateErrorFunctionT< double >
 
using FullyDifferentiableStateErrorFunction_p = ::std::shared_ptr< FullyDifferentiableStateErrorFunction >
 
using FullyDifferentiableStateErrorFunction_u = ::std::unique_ptr< FullyDifferentiableStateErrorFunction >
 
using FullyDifferentiableStateErrorFunction_w = ::std::weak_ptr< FullyDifferentiableStateErrorFunction >
 
using FullyDifferentiableStateErrorFunction_const_p = ::std::shared_ptr< const FullyDifferentiableStateErrorFunction >
 
using FullyDifferentiableStateErrorFunction_const_u = ::std::unique_ptr< const FullyDifferentiableStateErrorFunction >
 
using FullyDifferentiableStateErrorFunction_const_w = ::std::weak_ptr< const FullyDifferentiableStateErrorFunction >
 
using FullyDifferentiableStateErrorFunctiond_p = ::std::shared_ptr< FullyDifferentiableStateErrorFunctiond >
 
using FullyDifferentiableStateErrorFunctiond_u = ::std::unique_ptr< FullyDifferentiableStateErrorFunctiond >
 
using FullyDifferentiableStateErrorFunctiond_w = ::std::weak_ptr< FullyDifferentiableStateErrorFunctiond >
 
using FullyDifferentiableStateErrorFunctiond_const_p = ::std::shared_ptr< const FullyDifferentiableStateErrorFunctiond >
 
using FullyDifferentiableStateErrorFunctiond_const_u = ::std::unique_ptr< const FullyDifferentiableStateErrorFunctiond >
 
using FullyDifferentiableStateErrorFunctiond_const_w = ::std::weak_ptr< const FullyDifferentiableStateErrorFunctiond >
 
using UnionErrorFunction = UnionErrorFunctionT< float >
 
using UnionErrorFunctiond = UnionErrorFunctionT< double >
 
using UnionErrorFunction_p = ::std::shared_ptr< UnionErrorFunction >
 
using UnionErrorFunction_u = ::std::unique_ptr< UnionErrorFunction >
 
using UnionErrorFunction_w = ::std::weak_ptr< UnionErrorFunction >
 
using UnionErrorFunction_const_p = ::std::shared_ptr< const UnionErrorFunction >
 
using UnionErrorFunction_const_u = ::std::unique_ptr< const UnionErrorFunction >
 
using UnionErrorFunction_const_w = ::std::weak_ptr< const UnionErrorFunction >
 
using UnionErrorFunctiond_p = ::std::shared_ptr< UnionErrorFunctiond >
 
using UnionErrorFunctiond_u = ::std::unique_ptr< UnionErrorFunctiond >
 
using UnionErrorFunctiond_w = ::std::weak_ptr< UnionErrorFunctiond >
 
using UnionErrorFunctiond_const_p = ::std::shared_ptr< const UnionErrorFunctiond >
 
using UnionErrorFunctiond_const_u = ::std::unique_ptr< const UnionErrorFunctiond >
 
using UnionErrorFunctiond_const_w = ::std::weak_ptr< const UnionErrorFunctiond >
 

Enumerations

enum class  LogLevel {
  Disabled = 0 , Error , Warning , Info ,
  Debug , Trace
}
 Logging levels in descending order of verbosity. More...
 
enum  LimitType {
  MinMax , MinMaxJoint , MinMaxJointPassive , Linear ,
  LinearJoint , Ellipsoid , HalfPlane , LimitTypeCount
}
 
enum  JointParameterNames {
  TX = 0 , TY , TZ , RX ,
  RY , RZ , SC
}
 
enum class  RotationErrorType { RotationMatrixDifference , QuaternionLogMap }
 Defines different methods for computing rotation error between two quaternions. More...
 
enum class  VertexConstraintType { Position , Plane , Normal , SymmetricNormal }
 
enum class  CharacterFormat : uint8_t { Fbx , Gltf , Usd , Unknown }
 Represents the supported character formats. More...
 
enum class  KeepLocators { No , Yes }
 
enum class  LoadBlendShapes { No , Yes }
 
enum class  Permissive { No , Yes }
 
enum class  GltfFileFormat { Auto = 0 , Binary = 1 , Ascii = 2 }
 File format in which the character is saved. More...
 
enum class  FbxUpVector { XAxis = 1 , YAxis = 2 , ZAxis = 3 }
 Specifies which canonical axis represents up in the system (typically Y or Z). More...
 
enum class  FbxFrontVector { ParityEven = 1 , ParityOdd = 2 }
 Vector with origin at the screen pointing toward the camera. More...
 
enum class  FbxCoordSystem { RightHanded , LeftHanded }
 Specifies the third vector of the system. More...
 
enum class  UpVector { X = 0 , Y , Z , YNeg }
 This enumeration is used to define the primary up vector directions for various coordinate systems and orientations in a 3D environment. More...
 
enum class  Unit {
  M , DM , CM , MM ,
  Unknown
}
 An enumeration representing the units of measurement used in marker data files. More...
 
enum class  LocatorSpace { Local = 0 , Global = 1 }
 

Functions

voidaligned_malloc (size_t size, size_t align)
 
void aligned_free (void *ptr)
 
constexpr std::size_t roundUpToAlignment (std::size_t value, std::size_t alignment)
 
template<typename T , std::size_t Alignment = alignof(T)>
TalignedAlloc (std::size_t n)
 Allocates a block of memory that can hold n elements of type T with the specified alignment.
 
template<typename T , std::size_t Alignment = alignof(T), class Deleter = AlignedDeleter>
std::unique_ptr< T, DeletermakeAlignedUnique (std::size_t n, Deleter deleter=Deleter())
 Creates a std::unique_ptr for aligned memory.
 
template<typename T , std::size_t Alignment = alignof(T), class Deleter = AlignedDeleter>
std::shared_ptr< TmakeAlignedShared (std::size_t n, Deleter deleter=Deleter())
 Creates a std::shared_ptr for aligned memory.
 
template<class T , class U , std::size_t Alignment>
bool operator== (const AlignedAllocator< T, Alignment > &, const AlignedAllocator< U, Alignment > &)
 Checks if storage allocated from lhs can be deallocated from rhs, and vice versa.
 
template<class T , class U , std::size_t Alignment>
bool operator!= (const AlignedAllocator< T, Alignment > &, const AlignedAllocator< U, Alignment > &)
 Checks if storage allocated from lhs cannot be deallocated from rhs, and vice versa.
 
std::map< std::string, LogLevellogLevelMap ()
 
void setLogLevel (LogLevel level)
 
void setLogLevel (const std::string &levelStr)
 
LogLevel getLogLevel ()
 
template<typename StringType >
StringType trim (const StringType &text, const char *whiteChars=" \t")
 Returns a copy of the string from which all the characters in whiteChars at the beginning or at the end of the string have been removed.
 
template std::string trim (const std::string &text, const char *whiteChars)
 
template std::string_view trim (const std::string_view &text, const char *whiteChars)
 
std::string trim (const char *text, const char *whiteChars=" \t")
 Returns a copy of the string from which all the characters in whiteChars at the beginning or at the end of the string have been removed.
 
std::vector< std::string > tokenize (const std::string &inputString, const std::string &delimiters=" \t\r\n", bool trim=true)
 Tokenize a string using the specified delimiters.
 
std::vector< std::string_view > tokenize (std::string_view inputString, std::string_view delimiters=" \t\r\n", bool trim=true)
 Tokenize a string_view using the specified delimiters.
 
template<size_t Alignment>
size_t computeOffset (const Eigen::Ref< Eigen::MatrixXf > &mat)
 Computes the offset required for the matrix data to meet the alignment requirement.
 
template<size_t Alignment>
void checkAlignment (const Eigen::Ref< Eigen::MatrixXf > &mat, size_t offset=0)
 Checks if the data of the matrix is aligned correctly.
 
template<typename Derived , typename S >
FloatP dot (const Eigen::MatrixBase< Derived > &v1, const Vector3P< S > &v2)
 Calculates dot product of Eigen::Vector3f and 3-vector of packets.
 
template<typename Derived , typename S >
FloatP dot (const Vector3P< S > &v1, const Eigen::MatrixBase< Derived > &v2)
 Calculates dot product of Vector3P and Eigen::Vector3f.
 
template<typename S , typename Derived >
Vector3P< Soperator+ (const Eigen::MatrixBase< Derived > &v1, const Vector3P< S > &v2)
 Calculates summation of Eigen::Vector3f and Vector3P.
 
template<typename S , typename Derived >
Vector3P< Soperator+ (const Vector3P< S > &v1, const Eigen::MatrixBase< Derived > &v2)
 Calculates summation of Vector3P and Eigen::Vector3f.
 
template<typename S , typename Derived >
Vector3P< Soperator- (const Eigen::MatrixBase< Derived > &v1, const Vector3P< S > &v2)
 Calculates subtraction of Eigen::Vector3f and Vector3P.
 
template<typename S , typename Derived >
Vector3P< Soperator- (const Vector3P< S > &v1, const Eigen::MatrixBase< Derived > &v2)
 Calculates subtraction of Vector3P and Eigen::Vector3f.
 
template<typename S >
Vector3P< Soperator* (const Eigen::Quaternion< S > &q, const Vector3P< S > &vec)
 Calculates multiplication of quaternion and each 3x1 vector in packet.
 
template<typename S , typename Derived >
Vector3P< Soperator* (const Eigen::MatrixBase< Derived > &xf, const Vector3P< S > &vec)
 Calculates multiplication of 3x3 matrix and each 3x1 vector in packet.
 
template<typename S >
Vector3P< Soperator* (const Eigen::Transform< S, 3, Eigen::Affine > &xf, const Vector3P< S > &vec)
 Calculates affine transformation on each 3x1 vector in packet.
 
template<typename S >
Vector3P< Soperator* (const TransformT< S > &xf, const Vector3P< S > &vec)
 Calculates transformation on each 3x1 vector in packet using momentum::Transform.
 
template<typename S , typename Derived >
Vector3P< Scross (const Eigen::MatrixBase< Derived > &v1, const Vector3P< S > &v2)
 Calculates cross product of Eigen::Vector3f and Vector3P.
 
template<typename S , typename Derived >
Vector3P< Scross (const Vector3P< S > &v1, const Eigen::MatrixBase< Derived > &v2)
 Calculates cross product of Vector3P and Eigen::Vector3f.
 
template<typename T = float>
constexpr T nan () noexcept
 
template<typename T >
constexpr T Eps (T FloatEps=T(1e-7), T DoubleEps=T(1e-16))
 Returns the tolerance value based on the provided type T.
 
template<typename T = float>
constexpr T ln2 () noexcept
 
template<typename T = float>
constexpr T pi () noexcept
 
template<typename T = float>
constexpr T twopi () noexcept
 
template<typename T = float>
constexpr T toRad (T x=T(1)) noexcept
 Converts the given angle x (in degrees) to radians.
 
template<typename T = float>
constexpr T toDeg (T x=T(1)) noexcept
 Converts the given angle x (in radians) to degrees.
 
template<typename T = float>
constexpr T toM (T x=T(1)) noexcept
 Converts the given length x (in centimeters) to meters.
 
template<typename T = float>
constexpr T toCm (T x=T(1)) noexcept
 Converts the given length x (in meters) to centimeters.
 
template<typename T >
bool intersectFace (const MeshT< T > &mesh, const std::vector< Vector3< T > > &faceNormals, int32_t face0, int32_t face1)
 test whether two given faces of a mesh intersect with each other
 
template<typename T >
std::vector< std::pair< int32_t, int32_t > > intersectMeshBruteForce (const MeshT< T > &mesh)
 test if the mesh self intersects anywhere and return all intersecting face pairs using brute force
 
template<typename T >
std::vector< std::pair< int32_t, int32_t > > intersectMesh (const MeshT< T > &mesh)
 test if the mesh self intersects anywhere and return all intersecting face pairs using a bvh tree
 
template bool intersectFace< float > (const MeshT< float > &mesh, const std::vector< Vector3< float > > &faceNormals, const int32_t face0, const int32_t face1)
 
template bool intersectFace< double > (const MeshT< double > &mesh, const std::vector< Vector3< double > > &faceNormals, const int32_t face0, const int32_t face1)
 
template std::vector< std::pair< int32_t, int32_t > > intersectMeshBruteForce< float > (const MeshT< float > &mesh)
 
template std::vector< std::pair< int32_t, int32_t > > intersectMeshBruteForce< double > (const MeshT< double > &mesh)
 
template std::vector< std::pair< int32_t, int32_t > > intersectMesh< float > (const MeshT< float > &mesh)
 
template std::vector< std::pair< int32_t, int32_t > > intersectMesh< double > (const MeshT< double > &mesh)
 
template<typename T , typename T2 , int N>
std::vector< Eigen::Vector< T2, N > > castVectors (const std::vector< Eigen::Vector< T, N > > &vec_in)
 
template<typename T , typename T2 >
std::vector< Eigen::MatrixX< T2 > > castMatrices (std::span< const Eigen::MatrixX< T > > m_in)
 
void validateColumnIndices (std::span< const Eigen::Index > colIndices, Eigen::Index maxEntry)
 
template<typename T >
T uniform (const T &min, const T &max)
 Generates a random type T from the uniform distribution, using the global random number generator Random.
 
template<typename FixedSizeT >
FixedSizeT uniform (typename FixedSizeT::Scalar min, typename FixedSizeT::Scalar max)
 Generates a random fixed size vector/matrix from the uniform distribution, using the global random number generator Random.
 
template<typename DynamicVector >
DynamicVector uniform (Eigen::Index size, typename DynamicVector::Scalar min, typename DynamicVector::Scalar max)
 Generates a random dynamic size vector from the uniform distribution, using the global random number generator Random.
 
template<typename DynamicMatrix >
DynamicMatrix uniform (Eigen::Index rows, Eigen::Index cols, typename DynamicMatrix::Scalar min, typename DynamicMatrix::Scalar max)
 Generates a random type dynamic size matrix from the uniform distribution, using the global random number generator Random.
 
template<typename T >
Quaternion< TuniformQuaternion ()
 Generates a random quaternion from a uniform distribution on SO(3)
 
template<typename T >
Matrix3< TuniformRotationMatrix ()
 Generates a random rotation matrix from a uniform distribution on SO(3)
 
template<typename T >
Isometry3< TuniformIsometry3 (const Vector3< T > &min=Vector3< T >::Zero(), const Vector3< T > &max=Vector3< T >::Ones())
 Generates a random isometry (rigid transformation) from a uniform distribution on SE(3) based on input minimum and maximum 3D vectors for the translation part.
 
template<typename T >
Affine3< TuniformAffine3 (T scaleMin=0.1, T scaleMax=10.0, const Vector3< T > &min=Vector3< T >::Zero(), const Vector3< T > &max=Vector3< T >::Ones())
 Generates a random affine transformation from a uniform distribution on the space of all affine transformations.
 
template<typename T >
T normal (const T &mean, const T &sigma)
 Generates a random type T from the Gaussian distribution, using the global random number generator Random.
 
template<typename FixedSizeT >
FixedSizeT normal (typename FixedSizeT::Scalar mean, typename FixedSizeT::Scalar sigma)
 Generates a random fixed size vector/matrix from the Gaussian distribution, using the global random number generator Random.
 
template<typename DynamicVector >
DynamicVector normal (Eigen::Index size, typename DynamicVector::Scalar mean, typename DynamicVector::Scalar sigma)
 Generates a random dynamic size vector from the Gaussian distribution, using the global random number generator Random.
 
template<typename DynamicMatrix >
DynamicMatrix normal (Eigen::Index rows, Eigen::Index cols, typename DynamicMatrix::Scalar mean, typename DynamicMatrix::Scalar sigma)
 Generates a random dynamic size matrix from the Gaussian distribution, using the global random number generator Random.
 
template<typename T >
TransformT< TblendTransforms (std::span< const TransformT< T > > transforms, std::span< const T > weights)
 
template<typename T >
TransformT< Tslerp (const TransformT< T > &t1, const TransformT< T > &t2, T weight)
 Spherical linear interpolation between two transforms.
 
template TransformT< floatblendTransforms (std::span< const TransformT< float > > transforms, std::span< const float > weights)
 
template TransformT< doubleblendTransforms (std::span< const TransformT< double > > transforms, std::span< const double > weights)
 
template TransformT< floatslerp (const TransformT< float > &, const TransformT< float > &, float)
 
template TransformT< doubleslerp (const TransformT< double > &, const TransformT< double > &, double)
 
template<typename OtherScalar , template< typename... > class ContainerType, typename ObjectType >
decltype(autocast (const ContainerType< ObjectType > &originalContainer)
 Casts the scalar type of objects in a container that support the cast<>() method.
 
template MatrixX< floatpseudoInverse (const MatrixX< float > &mat)
 
template MatrixX< doublepseudoInverse (const MatrixX< double > &mat)
 
template MatrixX< floatpseudoInverse (const SparseMatrix< float > &mat)
 
template MatrixX< doublepseudoInverse (const SparseMatrix< double > &mat)
 
template Quaternion< floatquaternionExpMap (const Vector3< float > &v)
 
template Quaternion< doublequaternionExpMap (const Vector3< double > &v)
 
template Vector3< floatquaternionLogMap (const Quaternion< float > &q)
 
template Vector3< doublequaternionLogMap (const Quaternion< double > &q)
 
template Eigen::Matrix< float, 3, 4 > quaternionLogMapDerivative (const Quaternion< float > &q)
 
template Eigen::Matrix< double, 3, 4 > quaternionLogMapDerivative (const Quaternion< double > &q)
 
template Vector3< floatrotationMatrixToEuler (const Matrix3< float > &m, int axis0, int axis1, int axis2, EulerConvention convention)
 
template Vector3< doublerotationMatrixToEuler (const Matrix3< double > &m, int axis0, int axis1, int axis2, EulerConvention convention)
 
template Vector3< floatrotationMatrixToEulerXYZ (const Matrix3< float > &m, EulerConvention convention)
 
template Vector3< doublerotationMatrixToEulerXYZ (const Matrix3< double > &m, EulerConvention convention)
 
template Vector3< floatrotationMatrixToEulerZYX (const Matrix3< float > &m, EulerConvention convention)
 
template Vector3< doublerotationMatrixToEulerZYX (const Matrix3< double > &m, EulerConvention convention)
 
template Quaternion< floateulerToQuaternion (const Vector3< float > &angles, int axis0, int axis1, int axis2, EulerConvention convention)
 
template Quaternion< doubleeulerToQuaternion (const Vector3< double > &angles, int axis0, int axis1, int axis2, EulerConvention convention)
 
template Matrix3< floateulerToRotationMatrix (const Vector3< float > &angles, int axis0, int axis1, int axis2, EulerConvention convention)
 
template Matrix3< doubleeulerToRotationMatrix (const Vector3< double > &angles, int axis0, int axis1, int axis2, EulerConvention convention)
 
template Matrix3< floateulerXYZToRotationMatrix (const Vector3< float > &angles, EulerConvention convention)
 
template Matrix3< doubleeulerXYZToRotationMatrix (const Vector3< double > &angles, EulerConvention convention)
 
template Matrix3< floateulerZYXToRotationMatrix (const Vector3< float > &angles, EulerConvention convention)
 
template Matrix3< doubleeulerZYXToRotationMatrix (const Vector3< double > &angles, EulerConvention convention)
 
template Vector3f quaternionToEuler (const Quaternionf &q)
 
template Vector3d quaternionToEuler (const Quaterniond &q)
 
template std::tuple< bool, float, Eigen::Vector2< float > > closestPointsOnSegments< float > (const Eigen::Vector3< float > &o1, const Eigen::Vector3< float > &d1, const Eigen::Vector3< float > &o2, const Eigen::Vector3< float > &d2, const float maxDist)
 
template std::tuple< bool, double, Eigen::Vector2< double > > closestPointsOnSegments< double > (const Eigen::Vector3< double > &o1, const Eigen::Vector3< double > &d1, const Eigen::Vector3< double > &o2, const Eigen::Vector3< double > &d2, const double maxDist)
 
template float rotationMatrixToOneAxisEuler (const Matrix3< float > &m, int axis0)
 
template double rotationMatrixToOneAxisEuler (const Matrix3< double > &m, int axis0)
 
template Vector2< floatrotationMatrixToTwoAxisEuler (const Matrix3< float > &m, int axis0, int axis1)
 
template Vector2< doublerotationMatrixToTwoAxisEuler (const Matrix3< double > &m, int axis0, int axis1)
 
bool IsNanNoOpt (float f)
 NaN check function that isn't optimized away by fastmath.
 
constexpr size_t padToSimdAlignment (size_t size)
 Pads a row count to be a multiple of kJacobianRowAlignment for SIMD alignment.
 
template<typename T >
BlendWeightsT< TextractBlendWeights (const ParameterTransform &paramTransform, const ModelParametersT< T > &modelParams)
 Extracts blend shape weights from model parameters.
 
template<typename T >
BlendWeightsT< TextractFaceExpressionBlendWeights (const ParameterTransform &paramTransform, const ModelParametersT< T > &modelParams)
 Extracts facial expression blend shape weights from model parameters.
 
template<typename T >
void skinWithBlendShapes (const Character &character, const SkeletonStateT< T > &state, const ModelParametersT< T > &modelParams, MeshT< T > &outputMesh)
 Applies blend shape deformations and skeletal transformations to a mesh.
 
template<typename T >
void skinWithBlendShapes (const Character &character, const SkeletonStateT< T > &state, const BlendWeightsT< T > &blendWeights, MeshT< T > &outputMesh)
 Applies blend shape deformations and skeletal transformations to a mesh.
 
template void skinWithBlendShapes (const Character &character, const SkeletonStateT< float > &state, const BlendWeightsT< float > &modelParams, MeshT< float > &outputMesh)
 
template void skinWithBlendShapes (const Character &character, const SkeletonStateT< double > &state, const BlendWeightsT< double > &modelParams, MeshT< double > &outputMesh)
 
template void skinWithBlendShapes (const Character &character, const SkeletonStateT< float > &state, const ModelParametersT< float > &modelParams, MeshT< float > &outputMesh)
 
template void skinWithBlendShapes (const Character &character, const SkeletonStateT< double > &state, const ModelParametersT< double > &modelParams, MeshT< double > &outputMesh)
 
template BlendWeightsT< floatextractBlendWeights< float > (const ParameterTransform &paramTransform, const ModelParametersT< float > &modelParams)
 
template BlendWeightsT< doubleextractBlendWeights< double > (const ParameterTransform &paramTransform, const ModelParametersT< double > &modelParams)
 
template BlendWeightsT< floatextractFaceExpressionBlendWeights< float > (const ParameterTransform &paramTransform, const ModelParametersT< float > &modelParams)
 
template BlendWeightsT< doubleextractFaceExpressionBlendWeights< double > (const ParameterTransform &paramTransform, const ModelParametersT< double > &modelParams)
 
Character scaleCharacter (const Character &character, float scale)
 Scales the character (mesh and skeleton) by the desired amount.
 
Character transformCharacter (const Character &character, const Affine3f &xform)
 Transforms the character (mesh and skeleton) by the desired transformation matrix.
 
Character replaceSkeletonHierarchy (const Character &srcCharacter, const Character &tgtCharacter, const std::string &srcRootJoint, const std::string &tgtRootJoint)
 Replaces the part of target_character's skeleton rooted at target_root with the part of source_character's skeleton rooted at source_root.
 
Character removeJoints (const Character &character, std::span< const size_t > jointsToRemove)
 Removes the specified joints and any joints parented beneath them from the character.
 
MatrixXf mapMotionToCharacter (const MotionParameters &inputMotion, const Character &targetCharacter)
 Maps the input ModelParameter motion to a target character by matching model parameter names.
 
JointParameters mapIdentityToCharacter (const IdentityParameters &inputIdentity, const Character &targetCharacter)
 Maps the input JointParameter vector to a target character by matching joint names.
 
template<typename T >
CharacterT< TreduceMeshByVertices (const CharacterT< T > &character, const std::vector< bool > &activeVertices)
 Reduces the mesh to only include the specified vertices and associated faces.
 
template<typename T >
CharacterT< TreduceMeshByFaces (const CharacterT< T > &character, const std::vector< bool > &activeFaces)
 Reduces the mesh to only include the specified faces and associated vertices.
 
template<typename T >
std::vector< boolverticesToFaces (const MeshT< T > &mesh, const std::vector< bool > &activeVertices)
 Converts vertex selection to face selection.
 
template<typename T >
std::vector< boolfacesToVertices (const MeshT< T > &mesh, const std::vector< bool > &activeFaces)
 Converts face selection to vertex selection.
 
template CharacterT< floatreduceMeshByVertices< float > (const CharacterT< float > &character, const std::vector< bool > &activeVertices)
 
template CharacterT< doublereduceMeshByVertices< double > (const CharacterT< double > &character, const std::vector< bool > &activeVertices)
 
template CharacterT< floatreduceMeshByFaces< float > (const CharacterT< float > &character, const std::vector< bool > &activeFaces)
 
template CharacterT< doublereduceMeshByFaces< double > (const CharacterT< double > &character, const std::vector< bool > &activeFaces)
 
template std::vector< boolverticesToFaces< float > (const MeshT< float > &mesh, const std::vector< bool > &activeVertices)
 
template std::vector< boolverticesToFaces< double > (const MeshT< double > &mesh, const std::vector< bool > &activeVertices)
 
template std::vector< boolfacesToVertices< float > (const MeshT< float > &mesh, const std::vector< bool > &activeFaces)
 
template std::vector< boolfacesToVertices< double > (const MeshT< double > &mesh, const std::vector< bool > &activeFaces)
 
template<typename T >
bool overlaps (const Vector3< T > &originA, const Vector3< T > &directionA, const Vector2< T > &radiiA, T deltaA, const Vector3< T > &originB, const Vector3< T > &directionB, const Vector2< T > &radiiB, T deltaB, T &outDistance, Vector2< T > &outClosestPoints, T &outOverlap)
 Determines if two tapered capsules overlap.
 
template<typename T >
void updateAabb (axel::BoundingBox< T > &aabb, const Vector3< T > &originA, const Vector3< T > &direction, const Vector2< T > &radii)
 Updates an axis-aligned bounding box to encompass a tapered capsule.
 
template<typename T >
Eigen::SparseMatrix< TtoColumnMajor (const SparseRowMatrix< T > &mat)
 
template<typename T >
std::vector< Eigen::Matrix4< T > > computeSkinningTransforms (typename DeduceSpanType< const JointStateT< T > >::type jointState, const TransformationListT< T > &inverseBindPose)
 Computes the skinning transforms from joint states and inverse bind poses.
 
template<typename T >
std::vector< Vector3< T > > applySSD (const SkinWeights &skin, typename DeduceSpanType< const Vector3< T > >::type points, typename DeduceSpanType< const Eigen::Matrix4< T > >::type skinningTransforms)
 Applies forward SSD (linear blend skinning) to points using precomputed skinning transforms.
 
template<typename T >
std::vector< Vector3< T > > applySSD (const TransformationListT< T > &inverseBindPose, const SkinWeights &skin, typename DeduceSpanType< const Vector3< T > >::type points, typename DeduceSpanType< const JointStateT< T > >::type jointState)
 Applies forward SSD to points using joint states, returning new points.
 
template<typename T >
std::vector< Vector3< T > > applySSD (const TransformationListT< T > &inverseBindPose, const SkinWeights &skin, typename DeduceSpanType< const Vector3< T > >::type points, const SkeletonStateT< T > &state)
 Applies forward SSD to points using skeleton state, returning new points.
 
template<typename T >
std::vector< Vector3< T > > applySSD (const TransformationListT< T > &inverseBindPose, const SkinWeights &skin, typename DeduceSpanType< const Vector3< T > >::type points, const TransformationListT< T > &worldTransforms)
 Applies forward SSD to points using precomputed world transforms, returning new points.
 
template<typename T >
std::vector< Vector3< T > > applySSD (const TransformationListT< T > &inverseBindPose, const SkinWeights &skin, typename DeduceSpanType< const Vector3< T > >::type points, typename DeduceSpanType< const TransformT< T > >::type worldTransforms)
 Applies forward SSD to points using a span of world transforms, returning new points.
 
template<typename T >
void applySSD (const SkinWeights &skin, const MeshT< T > &mesh, typename DeduceSpanType< const Eigen::Matrix4< T > >::type skinningTransforms, MeshT< T > &outputMesh)
 Applies forward SSD to a mesh using precomputed skinning transforms.
 
template<typename T >
void applySSD (const TransformationListT< T > &inverseBindPose, const SkinWeights &skin, const MeshT< T > &mesh, typename DeduceSpanType< const JointStateT< T > >::type jointState, MeshT< T > &outputMesh)
 Applies forward SSD to a mesh using joint states, modifying output mesh.
 
template<typename T >
void applySSD (const TransformationListT< T > &inverseBindPose, const SkinWeights &skin, const MeshT< T > &mesh, const SkeletonStateT< T > &state, MeshT< T > &outputMesh)
 Applies forward SSD to a mesh using skeleton state, modifying output mesh.
 
template<typename T >
void applySSD (const TransformationListT< T > &inverseBindPose, const SkinWeights &skin, const MeshT< T > &mesh, const TransformationListT< T > &worldTransforms, MeshT< T > &outputMesh)
 Applies forward SSD to a mesh using precomputed world transforms.
 
template<typename T >
void applySSD (const TransformationListT< T > &inverseBindPose, const SkinWeights &skin, const MeshT< T > &mesh, typename DeduceSpanType< const TransformT< T > >::type worldTransforms, MeshT< T > &outputMesh)
 Applies forward SSD to a mesh using a span of world transforms.
 
Affine3f getInverseSSDTransformation (const TransformationList &inverseBindPose, const SkinWeights &skin, const SkeletonState &state, size_t index)
 Computes the inverse SSD transformation for a specific vertex.
 
void applyInverseSSD (const TransformationList &inverseBindPose, const SkinWeights &skin, std::span< const Vector3f > points, const SkeletonState &state, Mesh &mesh)
 Applies inverse SSD to points, storing results in a mesh.
 
std::vector< Vector3fapplyInverseSSD (const TransformationList &inverseBindPose, const SkinWeights &skin, std::span< const Vector3f > points, const SkeletonState &state)
 Applies inverse SSD to points, returning new points in bind pose space.
 
template std::vector< Eigen::Matrix4f > computeSkinningTransforms< float > (std::span< const JointStateT< float > > jointState, const TransformationListT< float > &inverseBindPose)
 
template std::vector< Eigen::Matrix4d > computeSkinningTransforms< double > (std::span< const JointStateT< double > > jointState, const TransformationListT< double > &inverseBindPose)
 
template std::vector< Vector3fapplySSD< float > (const SkinWeights &skin, std::span< const Vector3f > points, std::span< const Eigen::Matrix4f > skinningTransforms)
 
template std::vector< Vector3dapplySSD< double > (const SkinWeights &skin, std::span< const Vector3d > points, std::span< const Eigen::Matrix4d > skinningTransforms)
 
template std::vector< Vector3fapplySSD< float > (const TransformationListT< float > &inverseBindPose, const SkinWeights &skin, std::span< const Vector3f > points, std::span< const JointStateT< float > > jointState)
 
template std::vector< Vector3dapplySSD< double > (const TransformationListT< double > &inverseBindPose, const SkinWeights &skin, std::span< const Vector3d > points, std::span< const JointStateT< double > > jointState)
 
template std::vector< Vector3fapplySSD< float > (const TransformationListT< float > &inverseBindPose, const SkinWeights &skin, std::span< const Vector3f > points, const SkeletonStateT< float > &state)
 
template std::vector< Vector3dapplySSD< double > (const TransformationListT< double > &inverseBindPose, const SkinWeights &skin, std::span< const Vector3d > points, const SkeletonStateT< double > &state)
 
template std::vector< Vector3fapplySSD< float > (const TransformationListT< float > &inverseBindPose, const SkinWeights &skin, std::span< const Vector3f > points, const TransformationListT< float > &worldTransforms)
 
template std::vector< Vector3dapplySSD< double > (const TransformationListT< double > &inverseBindPose, const SkinWeights &skin, std::span< const Vector3d > points, const TransformationListT< double > &worldTransforms)
 
template std::vector< Vector3fapplySSD< float > (const TransformationListT< float > &inverseBindPose, const SkinWeights &skin, std::span< const Vector3f > points, std::span< const TransformT< float > > worldTransforms)
 
template std::vector< Vector3dapplySSD< double > (const TransformationListT< double > &inverseBindPose, const SkinWeights &skin, std::span< const Vector3d > points, std::span< const TransformT< double > > worldTransforms)
 
template void applySSD< float > (const SkinWeights &skin, const MeshT< float > &mesh, std::span< const Eigen::Matrix4f > skinningTransforms, MeshT< float > &outputMesh)
 
template void applySSD< double > (const SkinWeights &skin, const MeshT< double > &mesh, std::span< const Eigen::Matrix4d > skinningTransforms, MeshT< double > &outputMesh)
 
template void applySSD< float > (const TransformationListT< float > &inverseBindPose, const SkinWeights &skin, const MeshT< float > &mesh, std::span< const JointStateT< float > > jointState, MeshT< float > &outputMesh)
 
template void applySSD< double > (const TransformationListT< double > &inverseBindPose, const SkinWeights &skin, const MeshT< double > &mesh, std::span< const JointStateT< double > > jointState, MeshT< double > &outputMesh)
 
template void applySSD< float > (const TransformationListT< float > &inverseBindPose, const SkinWeights &skin, const MeshT< float > &mesh, const SkeletonStateT< float > &state, MeshT< float > &outputMesh)
 
template void applySSD< double > (const TransformationListT< double > &inverseBindPose, const SkinWeights &skin, const MeshT< double > &mesh, const SkeletonStateT< double > &state, MeshT< double > &outputMesh)
 
template void applySSD< float > (const TransformationListT< float > &inverseBindPose, const SkinWeights &skin, const MeshT< float > &mesh, const TransformationListT< float > &worldTransforms, MeshT< float > &outputMesh)
 
template void applySSD< double > (const TransformationListT< double > &inverseBindPose, const SkinWeights &skin, const MeshT< double > &mesh, const TransformationListT< double > &worldTransforms, MeshT< double > &outputMesh)
 
template void applySSD< float > (const TransformationListT< float > &inverseBindPose, const SkinWeights &skin, const MeshT< float > &mesh, std::span< const TransformT< float > > worldTransforms, MeshT< float > &outputMesh)
 
template void applySSD< double > (const TransformationListT< double > &inverseBindPose, const SkinWeights &skin, const MeshT< double > &mesh, std::span< const TransformT< double > > worldTransforms, MeshT< double > &outputMesh)
 
template<typename T >
Vector3< TgetSkinnedLocatorPosition (const SkinnedLocator &locator, const Vector3< T > &restPosition, const TransformationList &inverseBindPose, const SkeletonStateT< T > &state)
 Computes the world position of a skinned locator using linear blend skinning.
 
template Vector3< floatgetSkinnedLocatorPosition< float > (const SkinnedLocator &locator, const Vector3< float > &restPosition, const TransformationList &inverseBindPose, const SkeletonStateT< float > &state)
 
template Vector3< doublegetSkinnedLocatorPosition< double > (const SkinnedLocator &locator, const Vector3< double > &restPosition, const TransformationList &inverseBindPose, const SkeletonStateT< double > &state)
 
template<typename T >
Vector3< TgetSkinnedLocatorPosition (const SkinnedLocator &locator, const TransformationList &inverseBindPose, const SkeletonStateT< T > &state)
 Computes the world position of a skinned locator using linear blend skinning.
 
template Vector3< floatgetSkinnedLocatorPosition< float > (const SkinnedLocator &locator, const TransformationList &inverseBindPose, const SkeletonStateT< float > &state)
 
template Vector3< doublegetSkinnedLocatorPosition< double > (const SkinnedLocator &locator, const TransformationList &inverseBindPose, const SkeletonStateT< double > &state)
 
std::string_view toString (const LimitType type)
 
JointParameters applyPassiveJointParameterLimits (const ParameterLimits &limits, const JointParameters &jointParams)
 Only processes MinMaxJointPassive limits, clamping parameters to their ranges.
 
ParameterLimits getPoseConstraintParameterLimits (const std::string &name, const ParameterTransform &pt, float weight=1.0f)
 Creates MinMax limits from a pose constraint.
 
bool isInRange (const LimitLinear &limit, float value)
 If rangeMin and rangeMax are both 0, the limit applies to all values.
 
bool isInRange (const LimitLinearJoint &limit, float value)
 If rangeMin and rangeMax are both 0, the limit applies to all values.
 
template<typename T >
ParameterTransformT< TmapParameterTransformJoints (const ParameterTransformT< T > &parameterTransform, size_t numTargetJoints, const std::vector< size_t > &jointMapping)
 Construct a new parameter transform where the joints have been mapped to a new skeleton.
 
template<typename T >
std::tuple< ParameterTransformT< T >, ParameterLimitssubsetParameterTransform (const ParameterTransformT< T > &paramTransform, const ParameterLimits &paramLimitsOld, const ParameterSet &paramSet)
 Return a parameter mapping that only includes the listed parameters.
 
std::tuple< ParameterTransform, ParameterLimitsaddBlendShapeParameters (ParameterTransform paramTransform, ParameterLimits paramLimits, Eigen::Index nBlendShapes)
 
std::tuple< ParameterTransform, ParameterLimitsaddFaceExpressionParameters (ParameterTransform paramTransform, ParameterLimits paramLimits, Eigen::Index nFaceExpressionBlendShapes)
 
std::tuple< ParameterTransform, ParameterLimitsaddSkinnedLocatorParameters (ParameterTransform paramTransform, ParameterLimits paramLimits, const std::vector< bool > &activeLocators, const std::vector< std::string > &locatorNames={})
 Add a set of parameters that control the rest-space positions of the skinned locators.
 
template std::tuple< ParameterTransformT< float >, ParameterLimitssubsetParameterTransform (const ParameterTransformT< float > &paramTransform, const ParameterLimits &parameterLimits, const ParameterSet &paramSet)
 
template std::tuple< ParameterTransformT< double >, ParameterLimitssubsetParameterTransform (const ParameterTransformT< double > &paramTransform, const ParameterLimits &parameterLimits, const ParameterSet &paramSet)
 
template ParameterTransformT< floatmapParameterTransformJoints (const ParameterTransformT< float > &paramTransform, size_t numTargetJoints, const std::vector< size_t > &jointMapping)
 
template ParameterTransformT< doublemapParameterTransformJoints (const ParameterTransformT< double > &paramTransform, size_t numTargetJoints, const std::vector< size_t > &jointMapping)
 
template<typename T >
TransformT< TtransformAtoB (size_t jointA, size_t jointB, const Skeleton &referenceSkeleton, const SkeletonStateT< T > &skelState)
 Computes the relative transform between two joints in a skeleton.
 
template<typename T >
JointParametersT< TskeletonStateToJointParameters (const SkeletonStateT< T > &state, const Skeleton &skeleton)
 Invert the skeleton state (global transforms in world space) back to joint parameters (Euler angles in local space).
 
template<typename T >
JointParametersT< TskeletonStateToJointParameters (const TransformListT< T > &state, const Skeleton &skeleton)
 
template<typename T >
JointParametersT< TskeletonStateToJointParametersRespectingActiveParameters (const SkeletonStateT< T > &state, const Skeleton &skeleton, const VectorX< bool > &activeJointParams)
 Converts skeleton state back to joint parameters, respecting active joint parameter constraints.
 
template<typename T >
JointParametersT< TskeletonStateToJointParametersRespectingActiveParameters (const TransformListT< T > &state, const Skeleton &skeleton, const VectorX< bool > &activeJointParams)
 Converts transform list back to joint parameters, respecting active joint parameter constraints.
 
template TransformT< floattransformAtoB (size_t jointA, size_t jointB, const Skeleton &referenceSkeleton, const SkeletonStateT< float > &skelState)
 
template TransformT< doubletransformAtoB (size_t jointA, size_t jointB, const Skeleton &referenceSkeleton, const SkeletonStateT< double > &skelState)
 
template JointParametersT< floatskeletonStateToJointParameters (const SkeletonStateT< float > &state, const Skeleton &skeleton)
 
template JointParametersT< doubleskeletonStateToJointParameters (const SkeletonStateT< double > &state, const Skeleton &skeleton)
 
template JointParametersT< floatskeletonStateToJointParameters (const TransformListT< float > &state, const Skeleton &skeleton)
 
template JointParametersT< doubleskeletonStateToJointParameters (const TransformListT< double > &state, const Skeleton &skeleton)
 
template JointParametersT< floatskeletonStateToJointParametersRespectingActiveParameters (const SkeletonStateT< float > &state, const Skeleton &skeleton, const VectorX< bool > &activeJointParams)
 
template JointParametersT< doubleskeletonStateToJointParametersRespectingActiveParameters (const SkeletonStateT< double > &state, const Skeleton &skeleton, const VectorX< bool > &activeJointParams)
 
template JointParametersT< floatskeletonStateToJointParametersRespectingActiveParameters (const TransformListT< float > &state, const Skeleton &skeleton, const VectorX< bool > &activeJointParams)
 
template JointParametersT< doubleskeletonStateToJointParametersRespectingActiveParameters (const TransformListT< double > &state, const Skeleton &skeleton, const VectorX< bool > &activeJointParams)
 
ModelParameters extrapolateModelParameters (const ModelParameters &previous, const ModelParameters &current, float factor=kDefaultExtrapolateFactor, float maxDelta=kDefaultExtrapolateMaxDelta)
 Extrapolates model parameters by first clamping the difference between current and previous parameters to the range [-maxDelta, maxDelta], and then scaling this clamped difference by factor.
 
ModelParameters extrapolateModelParameters (const ModelParameters &previous, const ModelParameters &current, const ParameterSet &activeParams, float factor=kDefaultExtrapolateFactor, float maxDelta=kDefaultExtrapolateMaxDelta)
 Extrapolates model parameters considering active parameters.
 
template<typename T >
void gradient_jointParams_to_modelParams (const T &grad_jointParams, const Eigen::Index iJointParam, const ParameterTransform &parameterTransform, Eigen::Ref< Eigen::VectorX< T > > gradient)
 
template<typename T >
void jacobian_jointParams_to_modelParams (const Eigen::Ref< const Eigen::VectorX< T > > &jacobian_jointParams, const Eigen::Index iJointParam, const ParameterTransform &parameterTransform, Eigen::Ref< Eigen::MatrixX< T > > jacobian)
 
template<typename T >
void jacobian_jointParams_to_modelParams (const T &jacobian_jointParams, const Eigen::Index iJointParam, const ParameterTransform &parameterTransform, Eigen::Ref< Eigen::MatrixX< T > > jacobian)
 
template<typename T >
std::vector< PlaneDataT< T > > createFloorConstraints (const std::string &prefix, const LocatorList &locators, const Vector3< T > &floorNormal, const T &floorOffset, float weight)
 Create non-penetration half-plane constraints from locators with the input prefix.
 
template std::vector< PlaneDataT< float > > createFloorConstraints< float > (const std::string &prefix, const LocatorList &locators, const Vector3f &floorNormal, const float &floorOffset, const float weight)
 
template std::vector< PlaneDataT< double > > createFloorConstraints< double > (const std::string &prefix, const LocatorList &locators, const Vector3d &floorNormal, const double &floorOffset, const float weight)
 
template<typename T >
Eigen::Vector3< TcomputeTargetBaryPosition (const MeshT< T > &mesh, const PointTriangleVertexConstraintT< T > &c)
 
template<typename T >
Eigen::Vector3< TcomputeTargetTriangleNormal (const MeshT< T > &mesh, const PointTriangleVertexConstraintT< T > &c)
 
template<typename T >
Eigen::Vector3< TcomputeTargetPosition (const MeshT< T > &mesh, const PointTriangleVertexConstraintT< T > &c)
 
template<typename T >
void gradient_jointParams_to_modelParams (const T grad_jointParams, const Eigen::Index iJointParam, const ParameterTransform &parameterTransform, Eigen::Ref< Eigen::VectorX< T > > gradient)
 
template<typename T >
void jacobian_jointParams_to_modelParams (const Eigen::Ref< const Eigen::VectorX< T > > jacobian_jointParams, const Eigen::Index iJointParam, const ParameterTransform &parameterTransform, Eigen::Ref< Eigen::MatrixX< T > > jacobian)
 
template<typename T >
void jacobian_jointParams_to_modelParams (const T jacobian_jointParams, const Eigen::Index iJointParam, const ParameterTransform &parameterTransform, Eigen::Ref< Eigen::MatrixX< T > > jacobian)
 
template<typename T >
Eigen::Vector3< TcalculateDWorldPos (const momentum::Character &character, const SkeletonStateT< T > &state, const int vertexIndex, const Eigen::Vector3< T > &d_restPos)
 
template<typename T >
std::array< Eigen::Matrix3< T >, 3 > compute_d_targetNormal_d_vertexPos (const PointTriangleVertexConstraintT< T > &cons, const MeshT< T > &mesh)
 
template<typename T >
std::array< Eigen::Matrix3< T >, 3 > compute_d_targetPos_d_vertexPos (const PointTriangleVertexConstraintT< T > &cons, const MeshT< T > &mesh)
 
template<typename T >
Eigen::VectorX< TmapParameters (const ModelParametersT< T > &in, const std::vector< size_t > &mp)
 
__vectorcall DRJIT_INLINE void jacobian_jointParams_to_modelParams (const FloatP &jacobian_jointParams, const Eigen::Index iJointParam, const ParameterTransform &parameterTransform_, Eigen::Ref< Eigen::MatrixX< float > > jacobian)
 
template<typename T >
Eigen::Vector3< TcomputeTargetBaryPosition (const MeshT< T > &mesh, const SkinnedLocatorTriangleConstraintT< T > &c)
 
template<typename T >
Eigen::Vector3< TcomputeTargetTriangleNormal (const MeshT< T > &mesh, const SkinnedLocatorTriangleConstraintT< T > &c)
 
template<typename T >
Eigen::Vector3< TcomputeTargetPosition (const MeshT< T > &mesh, const SkinnedLocatorTriangleConstraintT< T > &c)
 
template<typename T >
std::array< Eigen::Matrix3< T >, 3 > compute_d_targetNormal_d_vertexPos (const SkinnedLocatorTriangleConstraintT< T > &cons, const MeshT< T > &mesh)
 
template<typename T >
std::array< Eigen::Matrix3< T >, 3 > compute_d_targetPos_d_vertexPos (const SkinnedLocatorTriangleConstraintT< T > &cons, const MeshT< T > &mesh)
 
template<typename T >
std::vector< ModelParametersT< T > > transformPose (const Character &character, const std::vector< ModelParametersT< T > > &modelParameters, const TransformT< T > &transforms)
 
template<typename T >
std::vector< ModelParametersT< T > > transformPose (const Character &character, const std::vector< ModelParametersT< T > > &modelParameters, const std::vector< TransformT< T > > &transforms, bool ensureContinuousOutput=true)
 Function which computes a new set of model parameters such that the character pose is a rigidly transformed version of the original pose.
 
template std::vector< ModelParametersT< float > > transformPose (const Character &characterFull, const std::vector< ModelParametersT< float > > &modelParametersFull, const std::vector< TransformT< float > > &transforms, bool ensureContinuousOutput)
 
template std::vector< ModelParametersT< double > > transformPose (const Character &characterFull, const std::vector< ModelParametersT< double > > &modelParametersFull, const std::vector< TransformT< double > > &transforms, bool ensureContinuousOutput)
 
template std::vector< ModelParametersT< float > > transformPose (const Character &character, const std::vector< ModelParametersT< float > > &modelParameters, const TransformT< float > &transform)
 
template std::vector< ModelParametersT< double > > transformPose (const Character &character, const std::vector< ModelParametersT< double > > &modelParameters, const TransformT< double > &transform)
 
std::string_view toString (VertexConstraintType type)
 
template<typename T , typename T2 >
Eigen::Vector3< TgetRotationDerivative (const JointStateT< T2 > &js, const size_t index, const Eigen::Vector3< T > &ref)
 
template<typename T , typename T2 >
Eigen::Vector3< TgetScaleDerivative (const JointStateT< T2 > &js, const Eigen::Vector3< T > &ref)
 
template<typename T , int N>
Eigen::Matrix< ceres::Jet< T, N >, N, 1 > buildJetVec (const Eigen::Matrix< T, N, 1 > &v)
 
template<typename T , int Rows, int Cols>
Eigen::Matrix< ceres::Jet< T, Cols *Rows >, Rows, ColsbuildJetMat (const Eigen::Matrix< T, Rows, Cols > &m)
 
template<typename T , typename T2 >
T times_parameterTransform_times_v (const T &value, const size_t jointParamIdx, const ParameterTransform &parameterTransform, Eigen::Ref< const Eigen::VectorX< T2 > > v)
 
template<typename T >
std::vector< Eigen::Index > computeSubsetParameterIndices (const ParameterTransformT< T > &parameterTransform, const ParameterSet &activeParams)
 
template<typename T >
Eigen::VectorX< TextractSubsetVec (Eigen::Ref< const Eigen::VectorX< T > > fullVec, const std::vector< Eigen::Index > &subsetIndexToFullParamIndex)
 
template<typename T >
Eigen::MatrixX< TextractSubsetMat (Eigen::Ref< const Eigen::MatrixX< T > > fullMat, const std::vector< Eigen::Index > &subsetIndexToFullParamIndex)
 
template<typename T >
Eigen::VectorX< TsubsetVecToFullVec (Eigen::Ref< const Eigen::VectorX< T > > subsetVec, const std::vector< Eigen::Index > &subsetIndexToFullParamIndex, Eigen::Index fullVecSize)
 
float sqr (float val)
 
template<typename T >
Eigen::VectorX< ThessianInverseTimes (Eigen::Ref< const Eigen::MatrixX< T > > jacobian, Eigen::Ref< const Eigen::VectorX< T > > v)
 
template<typename T >
std::vector< ErrorFunctionDerivativesT< T > > d_modelParams_d_inputs (const Skeleton &skeleton, const ParameterTransformT< T > &parameterTransform, const ParameterSet &activeParams, const ModelParametersT< T > &modelParameters, SkeletonSolverFunctionT< T > &solverFunction, Eigen::Ref< const Eigen::VectorX< T > > dLoss_dModelParams, T *gradientRmse)
 
template std::vector< ErrorFunctionDerivativesT< float > > d_modelParams_d_inputs< float > (const Skeleton &skeleton, const ParameterTransformT< float > &parameterTransform, const ParameterSet &activeParams, const ModelParametersT< float > &modelParameters, SkeletonSolverFunctionT< float > &solverFunction, Eigen::Ref< const Eigen::VectorX< float > > dLoss_dModelParams, float *gradientRmse)
 
template std::vector< ErrorFunctionDerivativesT< double > > d_modelParams_d_inputs< double > (const Skeleton &skeleton, const ParameterTransformT< double > &parameterTransform, const ParameterSet &activeParams, const ModelParametersT< double > &modelParameters, SkeletonSolverFunctionT< double > &solverFunction, Eigen::Ref< const Eigen::VectorX< double > > dLoss_dModelParams, double *gradientRmse)
 
 MOMENTUM_FWD_DECLARE_TEMPLATE_CLASS (DistanceErrorFunction)
 
 MOMENTUM_FWD_DECLARE_TEMPLATE_STRUCT (DistanceConstraintData)
 
 MOMENTUM_FWD_DECLARE_TEMPLATE_CLASS (FullyDifferentiableProjectionErrorFunction)
 
Character loadFullCharacter (const std::string &characterPath, const std::string &parametersPath=std::string(), const std::string &locatorsPath=std::string(), LoadBlendShapes loadBlendShapes=LoadBlendShapes::No)
 High level function to load a character of any type, with a local path.
 
Character loadFullCharacterFromBuffer (CharacterFormat format, std::span< const std::byte > characterBuffer, std::span< const std::byte > paramBuffer=std::span< const std::byte >(), std::span< const std::byte > locBuffer=std::span< const std::byte >(), LoadBlendShapes loadBlendShapes=LoadBlendShapes::No)
 Buffer version of loadFullCharacter function, supports .glb and .fbx file formats.
 
void saveCharacter (const filesystem::path &filename, const Character &character, float fps=120.f, const MatrixXf &motion=MatrixXf(), std::span< const std::vector< Marker > > markerSequence={}, const FileSaveOptions &options=FileSaveOptions())
 High level function to save a character with motion and markers to any supported format.
 
void saveCharacter (const filesystem::path &filename, const Character &character, float fps, std::span< const SkeletonState > skeletonStates, std::span< const std::vector< Marker > > markerSequence={}, const FileSaveOptions &options=FileSaveOptions())
 High level function to save a character with motion in skeleton states and markers to any supported format.
 
template<typename T >
std::span< Tcast_span (std::span< std::byte > bs)
 Casts a span of bytes to a span of a different type.
 
template<typename T >
std::span< const Tcast_span (std::span< const std::byte > bs)
 Casts a span of const bytes to a span of a different type.
 
std::istream & GetLineCrossPlatform (std::istream &is, std::string &line)
 Reads a line from the input stream, handling line endings for different platforms.
 
Character loadFbxCharacter (const filesystem::path &inputPath, KeepLocators keepLocators, Permissive permissive, LoadBlendShapes loadBlendShapes, bool stripNamespaces)
 
Character loadFbxCharacter (std::span< const std::byte > inputSpan, KeepLocators keepLocators, Permissive permissive, LoadBlendShapes loadBlendShapes, bool stripNamespaces)
 
std::tuple< Character, std::vector< MatrixXf >, floatloadFbxCharacterWithMotion (const filesystem::path &inputPath, KeepLocators keepLocators, Permissive permissive, LoadBlendShapes loadBlendShapes, bool stripNamespaces)
 
std::tuple< Character, std::vector< MatrixXf >, floatloadFbxCharacterWithMotion (std::span< const std::byte > inputSpan, KeepLocators keepLocators, Permissive permissive, LoadBlendShapes loadBlendShapes, bool stripNamespaces)
 
MarkerSequence loadFbxMarkerSequence (const filesystem::path &filename, bool stripNamespaces=true)
 Loads a MarkerSequence from an FBX file.
 
void saveFbx (const filesystem::path &filename, const Character &character, const MatrixXf &poses=MatrixXf(), const VectorXf &identity=VectorXf(), double framerate=120.0, std::span< const std::vector< Marker > > markerSequence={}, const FileSaveOptions &options=FileSaveOptions())
 Save a character with animation to an FBX file.
 
void saveFbxWithJointParams (const filesystem::path &filename, const Character &character, const MatrixXf &jointParams=MatrixXf(), double framerate=120.0, std::span< const std::vector< Marker > > markerSequence={}, const FileSaveOptions &options=FileSaveOptions())
 Save a character with animation using joint parameters directly.
 
void saveFbxWithSkeletonStates (const filesystem::path &filename, const Character &character, std::span< const SkeletonState > skeletonStates, double framerate=120.0, std::span< const std::vector< Marker > > markerSequence={}, const FileSaveOptions &options=FileSaveOptions())
 Save a character with animation using skeleton states directly.
 
void saveFbxModel (const filesystem::path &filename, const Character &character, const FileSaveOptions &options=FileSaveOptions())
 Save a character model (skeleton and mesh) without animation.
 
Character loadOpenFbxCharacter (const std::span< const std::byte > inputData, KeepLocators keepLocators, Permissive permissive, LoadBlendShapes loadBlendShapes, bool stripNamespaces)
 
Character loadOpenFbxCharacter (const filesystem::path &path, KeepLocators keepLocators, Permissive permissive, LoadBlendShapes loadBlendShapes, bool stripNamespaces)
 
std::tuple< Character, std::vector< MatrixXf >, floatloadOpenFbxCharacterWithMotion (std::span< const std::byte > inputData, KeepLocators keepLocators, Permissive permissive, LoadBlendShapes loadBlendShapes, bool stripNamespaces)
 
std::tuple< Character, std::vector< MatrixXf >, floatloadOpenFbxCharacterWithMotion (const filesystem::path &inputPath, KeepLocators keepLocators, Permissive permissive, LoadBlendShapes loadBlendShapes, bool stripNamespaces)
 
MarkerSequence loadOpenFbxMarkerSequence (const filesystem::path &filename, bool stripNamespaces)
 
std::vector< Eigen::Vector3i > triangulate (std::span< const uint32_t > indices, std::span< const uint32_t > offsets)
 
Character loadGltfCharacter (const fx::gltf::Document &model)
 Load a glTF character from a document.
 
Character loadGltfCharacter (const filesystem::path &gltfFilename)
 Load a glTF character from a file path.
 
Character loadGltfCharacter (std::span< const std::byte > byteSpan)
 Load a glTF character from a byte buffer.
 
std::tuple< MotionParameters, IdentityParameters, floatloadMotion (const filesystem::path &gltfFilename)
 Load motion data from a glTF file.
 
std::vector< int64_tloadMotionTimestamps (const filesystem::path &gltfFilename)
 Load per-frame timestamps from a glTF file.
 
std::tuple< Character, MatrixXf, JointParameters, floatloadCharacterWithMotion (const filesystem::path &gltfFilename)
 Load a glTF character with motion from a file path.
 
std::tuple< Character, MatrixXf, JointParameters, floatloadCharacterWithMotion (std::span< const std::byte > byteSpan)
 Load a glTF character from a buffer.
 
std::tuple< Character, MatrixXf, ModelParameters, floatloadCharacterWithMotionModelParameterScales (const filesystem::path &gltfFilename)
 Load a glTF character with motion and apply scale parameters to the motion.
 
std::tuple< Character, MatrixXf, ModelParameters, floatloadCharacterWithMotionModelParameterScales (std::span< const std::byte > byteSpan)
 Load a glTF character with motion and apply scale parameters to the motion.
 
std::tuple< Character, std::vector< SkeletonState >, std::vector< float > > loadCharacterWithSkeletonStates (std::span< const std::byte > byteSpan)
 Load a glTF character with motion in the form of skeleton states.
 
std::tuple< Character, std::vector< SkeletonState >, std::vector< float > > loadCharacterWithSkeletonStates (const filesystem::path &gltfFilename)
 Load a glTF character with motion in the form of skeleton states.
 
std::tuple< MatrixXf, JointParameters, floatloadMotionOnCharacter (const filesystem::path &gltfFilename, const Character &character)
 Load motion from a glTF file and map it to a character.
 
std::tuple< MatrixXf, JointParameters, floatloadMotionOnCharacter (std::span< const std::byte > byteSpan, const Character &character)
 Load motion from a buffer and map it to a character.
 
fx::gltf::Document makeCharacterDocument (const Character &character, float fps=120.0f, const MotionParameters &motion={}, const IdentityParameters &offsets={}, std::span< const std::vector< Marker > > markerSequence={}, bool embedResource=true, const FileSaveOptions &options=FileSaveOptions(), std::span< const int64_t > timestamps={})
 Create a glTF document from a character.
 
MarkerSequence loadMarkerSequence (const filesystem::path &filename)
 Load a marker sequence from a glTF file.
 
void saveGltfCharacter (const filesystem::path &filename, const Character &character, float fps=120.0f, const MotionParameters &motion={}, const IdentityParameters &offsets={}, std::span< const std::vector< Marker > > markerSequence={}, const FileSaveOptions &options=FileSaveOptions(), std::span< const int64_t > timestamps={})
 Save a character with motion to a glTF file.
 
void saveGltfCharacter (const filesystem::path &filename, const Character &character, float fps, std::span< const SkeletonState > skeletonStates, std::span< const std::vector< Marker > > markerSequence={}, const FileSaveOptions &options=FileSaveOptions())
 Save a character with skeleton states to a glTF file.
 
std::vector< std::byte > saveCharacterToBytes (const Character &character, float fps=120.0f, const MotionParameters &motion={}, const IdentityParameters &offsets={}, std::span< const std::vector< Marker > > markerSequence={}, const FileSaveOptions &options=FileSaveOptions(), std::span< const int64_t > timestamps={})
 Save a character with motion to a byte buffer.
 
int32_t getComponentSize (const fx::gltf::Accessor::ComponentType &componentType)
 
int32_t getTypeSize (const fx::gltf::Accessor::Type &ty)
 
template<typename T >
std::vector< TcopyAccessorBuffer (const fx::gltf::Document &model, int32_t id)
 
template<typename T >
std::vector< TcopyAlignedAccessorBuffer (const fx::gltf::Document &model, int32_t id)
 
template<typename T >
void setAccessorType (fx::gltf::Accessor &)
 
template<typename T >
int32_t createAccessorBuffer (fx::gltf::Document &model, std::span< T > data, const bool align=false, const bool normalized=false)
 
template<>
void setAccessorType< const int32_t > (fx::gltf::Accessor &accessor)
 
template<>
void setAccessorType< const float > (fx::gltf::Accessor &accessor)
 
template<>
void setAccessorType< const Vector2f > (fx::gltf::Accessor &accessor)
 
template<>
void setAccessorType< const Vector3f > (fx::gltf::Accessor &accessor)
 
template<>
void setAccessorType< const Vector4f > (fx::gltf::Accessor &accessor)
 
template<>
void setAccessorType< const Vector3b > (fx::gltf::Accessor &accessor)
 
template<>
void setAccessorType< const Vector3i > (fx::gltf::Accessor &accessor)
 
template<>
void setAccessorType< const Vector4s > (fx::gltf::Accessor &accessor)
 
template<>
void setAccessorType< const Vector4b > (fx::gltf::Accessor &accessor)
 
template<>
void setAccessorType< const Matrix4f > (fx::gltf::Accessor &accessor)
 
template<typename T >
int32_t createSampler (fx::gltf::Document &model, fx::gltf::Animation &anim, std::span< T > data, const std::span< float > &timestamps)
 
template<typename T >
int32_t createSampler (fx::gltf::Document &model, fx::gltf::Animation &anim, std::span< T > data, const int32_t timestampAccessor)
 
Vector3f toMomentumVec3f (const std::array< float, 3 > &vec) noexcept
 
Vector3f fromMomentumVec3f (const Vector3f &vec) noexcept
 
Quaternionf toMomentumQuaternionf (const std::array< float, 4 > &gltfQuat) noexcept
 
std::array< float, 4 > fromMomentumQuaternionf (const Quaternionf &quat) noexcept
 
void toMomentumVec3f (std::vector< Vector3f > &vec)
 
void fromMomentumVec3f (std::vector< Vector3f > &vec)
 
void fromMomentumVec3f (VectorXf &vec)
 
void parameterSetsToJson (const Character &character, nlohmann::json &j)
 
ParameterSets parameterSetsFromJson (const Character &character, const nlohmann::json &j)
 
void poseConstraintsToJson (const Character &character, nlohmann::json &j)
 
PoseConstraints poseConstraintsFromJson (const Character &character, const nlohmann::json &j)
 
void parameterTransformToJson (const Character &character, nlohmann::json &j)
 
ParameterTransform parameterTransformFromJson (const Character &character, const nlohmann::json &j)
 
void parameterLimitsToJson (const Character &character, nlohmann::json &j)
 
ParameterLimits parameterLimitsFromJson (const Character &character, const nlohmann::json &j)
 
template<typename Derived >
void toJson (const Eigen::MatrixBase< Derived > &mat, nlohmann::json &j)
 
template<typename T >
T fromJson (const nlohmann::json &j)
 
void mppcaToJson (const Character &character, nlohmann::json &j)
 
Character loadCharacterFromLegacyJson (const std::string &jsonPath)
 Loads a Character from a legacy JSON format that was previously used by older Python libraries (and some other tools).
 
Character loadCharacterFromLegacyJsonBuffer (std::span< const std::byte > jsonBuffer)
 Loads a Character from a legacy JSON buffer.
 
Character loadCharacterFromLegacyJsonString (const std::string &jsonString)
 Loads a Character from a legacy JSON string.
 
void saveCharacterToLegacyJson (const Character &character, const std::string &jsonPath)
 Saves a Character to legacy JSON format.
 
std::string characterToLegacyJsonString (const Character &character)
 Converts a Character to legacy JSON string.
 
nlohmann::json characterToLegacyJson (const Character &character)
 Converts a Character to legacy JSON object.
 
std::vector< MarkerSequenceloadC3d (const std::string &filename, UpVector up=UpVector::Y, std::span< const std::string > validMarkerNames={})
 Loads all the subjects from a C3D file into a vector of MarkerSequences.
 
template<typename T >
Vector3< TtoMomentumVector3 (const Vector3< T > &vec, UpVector up=UpVector::Z, Unit unit=Unit::MM)
 This function converts a 3D vector in the mocap marker coordinate system to the Momentum coordinate system.
 
template<typename T >
Vector3< TtoMomentumVector3 (const Vector3< T > &vec, UpVector up, const std::string &unitStr)
 This function converts a 3D vector in the mocap marker coordinate system to the Momentum coordinate system, using a string to specify the unit.
 
template Vector3< floattoMomentumVector3 (const Vector3< float > &vec, UpVector up, Unit unit)
 
template Vector3< doubletoMomentumVector3 (const Vector3< double > &vec, UpVector up, Unit unit)
 
template Vector3< floattoMomentumVector3 (const Vector3< float > &vec, UpVector up, const std::string &unitStr)
 
template Vector3< doubletoMomentumVector3 (const Vector3< double > &vec, UpVector up, const std::string &unitStr)
 
std::vector< MarkerSequenceloadMarkers (const std::string &filename, UpVector up=UpVector::Y, std::span< const std::string > validMarkerNames={})
 Loads all actor sequences from a marker file (c3d, trc, glb) and converts the positions to the target coordinate system.
 
std::optional< MarkerSequenceloadMarkersForMainSubject (const std::string &filename, UpVector up=UpVector::Y, std::span< const std::string > validMarkerNames={})
 Loads the main subject's marker data from a marker file (c3d, trc, glb) and converts the positions to the target coordinate system.
 
int findMainSubjectIndex (std::span< const MarkerSequence > markerSequences)
 Finds the "main subject" from a vector of MarkerSequences.
 
MarkerSequence loadTrc (const std::string &filename, UpVector up=UpVector::Y)
 Loads marker data from a TRC file into a MarkerSequence.
 
void saveMmo (const std::string &filename, std::span< const VectorXf > poses, const VectorXf &scale, const Character &character)
 Save motion data using character parameter mapping.
 
void saveMmo (const std::string &filename, const MatrixXf &poses, const VectorXf &scale, const Character &character, const MatrixXf &additionalParameters=MatrixXf(), std::span< const std::string > additionalParameterNames=std::vector< std::string >())
 Save motion data with optional additional parameters.
 
void saveMmo (const std::string &filename, const MatrixXf &poses, const VectorXf &scale, std::span< const std::string > parameterNames, std::span< const std::string > jointNames)
 Save motion data with explicit parameter and joint names.
 
std::tuple< MatrixXf, VectorXfmapMotionToCharacter (const MatrixXf &poses, const VectorXf &offsets, std::span< const std::string > parameterNames, std::span< const std::string > jointNames, const Character &character)
 Map motion data from one parameter space to character parameter space.
 
std::tuple< MatrixXf, VectorXfloadMmo (const std::string &filename, const Character &character)
 Load motion data and map to character parameter space.
 
std::tuple< MatrixXf, std::vector< std::string > > getAuxiliaryDataFromMotion (const MatrixXf &poses, std::span< const std::string > parameterNames)
 Extract auxiliary data from motion parameters.
 
std::tuple< MatrixXf, VectorXf, std::vector< std::string >, std::vector< std::string > > loadMmo (const std::string &filename)
 Load motion data from file.
 
BlendShapeBase loadBlendShapeBase (const filesystem::path &filename, int expectedShapes=-1, int expectedVertices=-1)
 Loads blend shape vectors from a file without base shape.
 
BlendShapeBase loadBlendShapeBase (std::istream &data, int expectedShapes=-1, int expectedVertices=-1)
 Loads blend shape vectors from a stream without base shape.
 
BlendShape loadBlendShape (const filesystem::path &filename, int expectedShapes=-1, int expectedVertices=-1)
 Loads a blend shape from a file, including base shape and shape vectors.
 
BlendShape loadBlendShape (std::istream &data, int expectedShapes=-1, int expectedVertices=-1)
 Loads a blend shape from a stream, including base shape and shape vectors.
 
void saveBlendShapeBase (const filesystem::path &filename, const BlendShapeBase &blendShapeBase)
 Saves a blend shape base (shape vectors) to a file.
 
void saveBlendShape (const filesystem::path &filename, const BlendShape &blendShape)
 Saves a blend shape to a file.
 
void saveBlendShapeBase (std::ostream &os, const BlendShapeBase &blendShapeBase)
 Saves a blend shape base (shape vectors) to a stream.
 
void saveBlendShape (std::ostream &os, const BlendShape &blendShape)
 Saves a blend shape to a stream.
 
PoseShape loadPoseShape (const std::string &filename, const Character &character)
 Loads pose shape data from a binary file.
 
LocatorList loadLocators (const filesystem::path &filename, const Skeleton &skeleton, const ParameterTransform &parameterTransform)
 
LocatorList loadLocatorsFromBuffer (std::span< const std::byte > rawData, const Skeleton &skeleton, const ParameterTransform &parameterTransform)
 
void saveLocators (const filesystem::path &filename, const LocatorList &locators, const Skeleton &skeleton, const LocatorSpace space)
 
std::shared_ptr< const MppcaloadMppca (const std::span< const unsigned char > posePriorDataRaw)
 
std::shared_ptr< const MppcaloadMppca (const std::string &name)
 
std::shared_ptr< const MppcaloadMppca (std::istream &inputStream)
 
void saveMppca (const Mppca &mppca, const std::string &name)
 
ParameterLimits parseParameterLimits (const io_detail::SectionContent &content, const Skeleton &skeleton, const ParameterTransform &parameterTransform)
 
ParameterLimits parseParameterLimits (const std::string &data, const Skeleton &skeleton, const ParameterTransform &parameterTransform, size_t lineOffset)
 
std::string writeParameterLimits (const ParameterLimits &parameterLimits, const Skeleton &skeleton, const ParameterTransform &parameterTransform)
 
std::unordered_map< std::string, std::string > loadMomentumModel (const filesystem::path &filename)
 
std::unordered_map< std::string, std::string > loadMomentumModelFromBuffer (std::span< const std::byte > buffer)
 
ParameterTransform parseParameterTransform (const SectionContent &content, const Skeleton &skeleton)
 
ParameterTransform parseParameterTransform (const std::string &data, const Skeleton &skeleton, size_t lineOffset)
 
ParameterSets parseParameterSets (const SectionContent &content, const ParameterTransform &pt)
 
ParameterSets parseParameterSets (const std::string &data, const ParameterTransform &pt, size_t lineOffset)
 
PoseConstraints parsePoseConstraints (const SectionContent &content, const ParameterTransform &pt)
 
PoseConstraints parsePoseConstraints (const std::string &data, const ParameterTransform &pt, size_t lineOffset)
 
std::tuple< ParameterTransform, ParameterLimitsloadModelDefinition (const filesystem::path &filename, const Skeleton &skeleton)
 
std::tuple< ParameterTransform, ParameterLimitsloadModelDefinition (std::span< const std::byte > rawData, const Skeleton &skeleton)
 
std::string writeParameterTransform (const ParameterTransform &parameterTransform, const Skeleton &skeleton)
 
std::string writeParameterSets (const ParameterSets &parameterSets)
 
std::string writePoseConstraints (const PoseConstraints &poseConstraints)
 
std::string writeModelDefinition (const Skeleton &skeleton, const ParameterTransform &parameterTransform, const ParameterLimits &parameterLimits)
 Write complete model definition file.
 
ParameterTransform parseParameterTransform (const io_detail::SectionContent &content, const Skeleton &skeleton)
 
ParameterSets parseParameterSets (const io_detail::SectionContent &content, const ParameterTransform &pt)
 
PoseConstraints parsePoseConstraints (const io_detail::SectionContent &content, const ParameterTransform &pt)
 
void loadParameters (std::unordered_map< std::string, std::string > &param, Character &character)
 
template<typename T >
CharacterT< TloadUrdfCharacter (const filesystem::path &filepath)
 Loads a character from a URDF file.
 
template CharacterT< floatloadUrdfCharacter (const filesystem::path &filepath)
 
template<typename T >
CharacterT< TloadUrdfCharacter (std::span< const std::byte > bytes)
 Loads a character from a URDF file using the provided byte data.
 
template CharacterT< floatloadUrdfCharacter (std::span< const std::byte > bytes)
 
Character loadUsdCharacter (const filesystem::path &inputPath)
 Load a USD character from a local file path.
 
Character loadUsdCharacter (std::span< const std::byte > inputSpan)
 Load a USD character from a buffer.
 
void saveUsd (const filesystem::path &filename, const Character &character)
 Save a character to a USD file.
 
void logMesh (const rerun::RecordingStream &rec, const std::string &streamName, const Mesh &mesh, std::optional< rerun::Color > color)
 
void logJoints (const rerun::RecordingStream &rec, const std::string &streamName, const Skeleton &skeleton, const JointStateList &jointStates)
 
void logMarkers (const rerun::RecordingStream &rec, const std::string &streamName, std::span< const Marker > markers)
 
void logLocators (const rerun::RecordingStream &rec, const std::string &streamName, const LocatorList &locators, const LocatorState &locatorState)
 
void logMarkerLocatorCorrespondence (const rerun::RecordingStream &rec, const std::string &streamName, const std::map< std::string, size_t > &locatorLookup, const LocatorState &locatorState, std::span< const Marker > markers, const float kPositionErrorThreshold)
 
void logModelParams (const rerun::RecordingStream &rec, const std::string &worldPrefix, const std::string &posePrefix, std::span< const std::string > names, const Eigen::VectorXf &params)
 
void logJointParams (const rerun::RecordingStream &rec, const std::string &worldPrefix, const std::string &posePrefix, std::span< const std::string > names, const Eigen::VectorXf &params)
 
void logModelParamNames (const rerun::RecordingStream &rec, const std::string &worldPrefix, const std::string &posePrefix, std::span< const std::string > names)
 
void logJointParamNames (const rerun::RecordingStream &rec, const std::string &worldPrefix, const std::string &posePrefix, std::span< const std::string > names)
 
void logBvh (const rerun::RecordingStream &rec, const std::string &streamName, const CollisionGeometry &collisionGeometry, const SkeletonState &skeletonState)
 
void logCollisionGeometry (const rerun::RecordingStream &rec, const std::string &streamName, const CollisionGeometry &collisionGeometry, const SkeletonState &skeletonState)
 
void logCharacter (const rerun::RecordingStream &rec, const std::string &charStreamName, const Character &character, const CharacterState &characterState, const rerun::Color &color)
 
bool redirectLogsToRerun (const rerun::RecordingStream &rec)
 Redirects logs from the XR_LOG framework to the Rerun logger.
 
template<typename T >
auto makeScalar (T value)
 
auto makeSeriesLine ()
 
auto makeSeriesLineWithName (const std::string &name)
 
void setTimeSeconds (const rerun::RecordingStream &rec, const std::string &timelineName, double seconds)
 
template<typename... Args>
auto makeTransform3D (Args &&... args)
 
void logAxes3D (const rerun::RecordingStream &rec, const std::string &path, float axisLength)
 
void addIOOptions (CLI::App &app, std::shared_ptr< IOOptions > ioOptions)
 
void addModelOptions (CLI::App &app, std::shared_ptr< ModelOptions > modelOptions)
 
void addCalibrationOptions (CLI::App &app, std::shared_ptr< CalibrationConfig > config)
 
void addTrackingOptions (CLI::App &app, std::shared_ptr< TrackingConfig > config)
 
void addRefineOptions (CLI::App &app, std::shared_ptr< RefineConfig > config)
 
std::tuple< momentum::Character, momentum::ModelParametersloadCalibratedModel (const std::string &modelFile)
 
std::tuple< momentum::Character, momentum::ModelParametersloadCharacterWithIdentity (const ModelOptions &modelFiles)
 
void saveMotion (const std::string &outFile, const momentum::Character &character, const momentum::ModelParameters &identity, Eigen::MatrixXf &finalMotion, std::span< const std::vector< momentum::Marker > > markerData, double fps, bool saveMarkerMesh=true, std::span< const int64_t > timestamps={})
 Save the given character and motion to a GLB or FBX file.
 
std::vector< size_tsampleFrames (momentum::Character &character, const MatrixXf &initialMotion, std::span< const std::vector< momentum::Marker > > markerData, const ParameterSet &parameters, const size_t frameStride, const size_t numSamples)
 Sample representative frames from motion data to maximize parameter variance.
 
Eigen::MatrixXf trackSequence (const std::span< const std::vector< Marker > > markerData, const Character &character, const ParameterSet &globalParams, const MatrixXf &initialMotion, const TrackingConfig &config, float regularizer, const size_t frameStride, bool enforceFloorInFirstFrame, const std::string &firstFramePoseConstraintSet, float targetHeightCm)
 Track motion across multiple frames simultaneously with temporal constraints.
 
Eigen::MatrixXf trackSequence (const std::span< const std::vector< Marker > > markerData, const Character &character, const ParameterSet &globalParams, const MatrixXf &initialMotion, const TrackingConfig &config, const std::vector< size_t > &frames, float regularizer, bool enforceFloorInFirstFrame, const std::string &firstFramePoseConstraintSet, float targetHeightCm)
 Track motion across multiple frames simultaneously for specific frame indices.
 
bool isGlobalTransformZero (const Eigen::VectorXf &dof, const ParameterSet &rigidParams)
 Check if the global transform is zero by checking if any rigid parameters are non-zero.
 
Eigen::MatrixXf trackPosesPerframe (const std::span< const std::vector< Marker > > markerData, const Character &character, const ModelParameters &globalParams, const TrackingConfig &config, const size_t frameStride)
 Track poses independently per frame with fixed character identity.
 
Eigen::MatrixXf trackPosesForFrames (const std::span< const std::vector< Marker > > markerData, const Character &character, const MatrixXf &initialMotion, const TrackingConfig &config, const std::vector< size_t > &frameIndices, bool isContinuous)
 Track poses independently for specific frame indices with fixed character identity.
 
Character addSkinnedLocatorParametersToTransform (Character character)
 
void calibrateModel (const std::span< const std::vector< Marker > > markerData, const CalibrationConfig &config, Character &character, ModelParameters &identity, const std::array< float, 3 > &regularizerWeights)
 
void calibrateLocators (const std::span< const std::vector< Marker > > markerData, const CalibrationConfig &config, const ModelParameters &identity, Character &character)
 Calibrate only locator positions with fixed character identity parameters.
 
MatrixXf refineMotion (std::span< const std::vector< momentum::Marker > > markerData, const MatrixXf &motion, const RefineConfig &config, momentum::Character &character)
 Refine existing motion by smoothing and optionally recalibrating identity/locators.
 
std::pair< float, floatgetLocatorError (std::span< const std::vector< momentum::Marker > > markerData, const MatrixXf &motion, momentum::Character &character)
 Compute average and maximum marker tracking errors across all frames.
 
Eigen::MatrixXf trackSequence (std::span< const std::vector< momentum::Marker > > markerData, const momentum::Character &character, const momentum::ParameterSet &globalParams, const Eigen::MatrixXf &initialMotion, const TrackingConfig &config, float regularizer=0.0, size_t frameStride=1, bool enforceFloorInFirstFrame=false, const std::string &firstFramePoseConstraintSet="", float targetHeightCm=0.0f)
 Use multiple frames to solve for global parameters such as body proportions and/or marker offsets together with the motion.
 
Eigen::MatrixXf trackSequence (std::span< const std::vector< momentum::Marker > > markerData, const momentum::Character &character, const momentum::ParameterSet &globalParams, const Eigen::MatrixXf &initialMotion, const TrackingConfig &config, const std::vector< size_t > &frames, float regularizer=0.0, bool enforceFloorInFirstFrame=false, const std::string &firstFramePoseConstraintSet="", float targetHeightCm=0.0f)
 Use multiple frames to solve for global parameters such as body proportions and/or marker offsets together with the motion.
 
Eigen::MatrixXf trackPosesPerframe (std::span< const std::vector< momentum::Marker > > markerData, const momentum::Character &character, const momentum::ModelParameters &globalParams, const TrackingConfig &config, size_t frameStride=1)
 Track poses per-frame given a calibrated character.
 
Eigen::MatrixXf trackPosesForFrames (std::span< const std::vector< momentum::Marker > > markerData, const momentum::Character &character, const Eigen::MatrixXf &initialMotion, const TrackingConfig &config, const std::vector< size_t > &frameIndices, bool isContinuous=false)
 Track poses for given frames.
 
void calibrateModel (std::span< const std::vector< momentum::Marker > > markerData, const CalibrationConfig &config, momentum::Character &character, momentum::ModelParameters &identity, const std::array< float, 3 > &regularizerWeights={0.0f, 0.0f, 0.0f})
 Calibrate body proportions and locator offsets of a character from input marker data.
 
void calibrateLocators (std::span< const std::vector< momentum::Marker > > markerData, const CalibrationConfig &config, const momentum::ModelParameters &identity, momentum::Character &character)
 Calibrate locator offsets of a character from input identity and marker data.
 
Eigen::MatrixXf refineMotion (std::span< const std::vector< momentum::Marker > > markerData, const Eigen::MatrixXf &motion, const RefineConfig &config, momentum::Character &character)
 
std::pair< float, floatgetLocatorError (std::span< const std::vector< momentum::Marker > > markerData, const Eigen::MatrixXf &motion, momentum::Character &character)
 Get the error of the locator motion vs the markers.
 
Eigen::MatrixXf processMarkers (momentum::Character &character, momentum::ModelParameters &identity, const std::vector< std::vector< momentum::Marker > > &markerData, const TrackingConfig &trackingConfig, const CalibrationConfig &calibrationConfig, bool calibrate=true, size_t firstFrame=0, size_t maxFrames=0)
 Processes marker data for a character model.
 
void processMarkerFile (const std::string &inputMarkerFile, const std::string &outputFile, const TrackingConfig &trackingConfig, const CalibrationConfig &calibrationConfig, const ModelOptions &modelOptions, bool calibrate, size_t firstFrame=0, size_t maxFrames=0)
 Runs marker tracking on an input marker file (e.g.
 
std::vector< std::vector< PositionData > > createConstraintData (const std::span< const std::vector< Marker > > markerData, const LocatorList &locators)
 
std::vector< std::vector< SkinnedLocatorConstraint > > createSkinnedConstraintData (const std::span< const std::vector< Marker > > markerData, const SkinnedLocatorList &locators)
 
std::pair< Eigen::Vector< uint32_t, kMaxSkinJoints >, Eigen::Vector< float, kMaxSkinJoints > > averageTriangleSkinWeights (const Character &character, int triangleIndex, const Eigen::Vector3f &barycentric)
 
bool isRelatedJoint (const momentum::Skeleton &skeleton, uint32_t jointA, uint32_t jointB)
 Check if two joints are related (same joint, parent-child, or child-parent relationship).
 
ClosestPointOnMeshResult closestPointOnMeshMatchingParent (const momentum::Mesh &mesh, const momentum::SkinWeights &skin, const momentum::Skeleton &skeleton, const Eigen::Vector3f &p_world, uint32_t parentIdx, float cutoffWeight=0.02)
 
momentum::Character locatorsToSkinnedLocators (const momentum::Character &sourceCharacter, float maxDistance=3.0f, float minSkinWeight=0.03f, bool verbose=false)
 Convert locators to skinned locators by finding the closest point on the mesh surface that matches the correct bone index and using the skinned weights from that point.
 
momentum::Character skinnedLocatorsToLocators (const momentum::Character &sourceCharacter)
 Convert skinned locators to regular locators by selecting the bone with the highest skin weight.
 
std::vector< momentum::SkinnedLocatorTriangleConstraintT< float > > createSkinnedLocatorMeshConstraints (const momentum::Character &character, const ModelParameters &modelParams, float targetDepth)
 
Character createLocatorCharacter (const Character &sourceCharacter, const std::string &prefix)
 
LocatorList extractLocatorsFromCharacter (const Character &locatorCharacter, const CharacterParameters &calibParams)
 
SkinnedLocatorList extractSkinnedLocatorsFromCharacter (const Character &locatorCharacter, const CharacterParameters &calibParams)
 
ModelParameters extractParameters (const ModelParameters &params, const ParameterSet &parameterSet)
 
std::tuple< Eigen::VectorXf, LocatorList, SkinnedLocatorListextractIdAndLocatorsFromParams (const ModelParameters &param, const Character &sourceCharacter, const Character &targetCharacter)
 
Mesh extractBlendShapeFromParams (const momentum::ModelParameters &param, const momentum::Character &sourceCharacter)
 
void fillIdentity (const ParameterSet &idSet, const ModelParameters &identity, Eigen::MatrixXf &motionNoId)
 
void removeIdentity (const ParameterSet &idSet, const ModelParameters &identity, Eigen::MatrixXf &motionWithId)
 
ModelParameters jointIdentityToModelIdentity (const Character &c, const ParameterSet &idSet, const JointParameters &jointIdentity)
 
std::vector< std::vector< Marker > > extractMarkersFromMotion (const Character &character, const Eigen::MatrixXf &motion)
 
std::vector< std::vector< momentum::PositionData > > createConstraintData (std::span< const std::vector< momentum::Marker > > markerData, const momentum::LocatorList &locators)
 
std::vector< std::vector< momentum::SkinnedLocatorConstraint > > createSkinnedConstraintData (std::span< const std::vector< momentum::Marker > > markerData, const momentum::SkinnedLocatorList &locators)
 
Matrix Utilities
template<typename T >
MatrixX< TpseudoInverse (const MatrixX< T > &mat)
 Calculates the pseudo-inverse of a matrix.
 
template<typename T >
MatrixX< TpseudoInverse (const SparseMatrix< T > &mat)
 Calculates the pseudo-inverse of a sparse matrix.
 
Math Utilities
ParameterSet allParams ()
 Creates a ParameterSet with all parameters set to active.
 
template<class T >
T sqr (const T &x)
 Computes the square of a value.
 
template<typename T = float>
bool isApprox (T l, T r, T eps=Eps< T >(1e-4, 1e-6)) noexcept
 Determines if two values are approximately equal within a given tolerance.
 

Variables

constexpr size_t kAvxPacketSize = 8
 
constexpr size_t kAvxAlignment = kAvxPacketSize * sizeof(float)
 
constexpr size_t kSimdPacketSize = drjit::DefaultSize
 
constexpr size_t kSimdAlignment = kSimdPacketSize * sizeof(float)
 
constexpr int Dynamic = Eigen::Dynamic
 
constexpr size_t kMaxModelParams = 2048
 
constexpr size_t kJacobianRowAlignment = 8
 Alignment for SIMD operations on Jacobian rows (8 floats = 32 bytes for AVX).
 
template<typename T >
const std::array< Vector3< T >, 3 > RotationAxis
 
constexpr float kDefaultExtrapolateFactor = 0.8f
 
constexpr float kDefaultExtrapolateMaxDelta = 0.4f
 
constexpr uint32_t kMaxSkinJoints = 8
 Maximum number of joints that can influence a single vertex.
 
constexpr size_t kParametersPerJoint = 7
 
constexpr std::array< const char *, kParametersPerJointkJointParameterNames {"tx", "ty", "tz", "rx", "ry", "rz", "sc"}
 
constexpr size_t kInvalidIndex = std::numeric_limits<size_t>::max()
 
constexpr float kPositionWeight = 1e-4f
 
constexpr size_t kAllFrames = SIZE_MAX
 
template<typename T >
constexpr T kVelocityMagnitudeEpsilon = T(1e-6)
 Epsilon for smooth velocity magnitude approximation: ||v||_smooth = sqrt(||v||^2 + eps^2)
 
constexpr const charkMomentumMarkersRootProperty = "Momentum_Markers_Root"
 
constexpr const charkMomentumMarkerProperty = "Momentum_Marker"
 
constexpr uint32_t kInvalidTexCoord = static_cast<uint32_t>(-1)
 

Geometry Utilities

enum class  EulerConvention { Intrinsic , Extrinsic }
 The Euler angles convention. More...
 
template<typename T >
Quaternion< TquaternionExpMap (const Vector3< T > &v)
 Computes the exponential map from a rotation vector (axis-angle in R^3) to a quaternion.
 
template<typename T >
Vector3< TquaternionLogMap (const Quaternion< T > &q)
 Computes the logarithmic map from a quaternion to a rotation vector (axis-angle in R^3).
 
template<typename T >
Eigen::Matrix< T, 3, 4 > quaternionLogMapDerivative (const Quaternion< T > &q)
 Computes the derivative of the logmap with respect to quaternion components.
 
template<typename T >
Vector3< TrotationMatrixToEuler (const Matrix3< T > &m, int axis0, int axis1, int axis2, EulerConvention convention=EulerConvention::Intrinsic)
 Converts rotation matrix to Euler angles.
 
template<typename T >
Vector3< TrotationMatrixToEulerXYZ (const Matrix3< T > &m, EulerConvention convention=EulerConvention::Intrinsic)
 An optimized version of rotationMatrixToEuler(m, 0, 1, 2, convention) or rotationMatrixToEuler(m, 2, 1, 0, convention).reverse().
 
template<typename T >
Vector3< TrotationMatrixToEulerZYX (const Matrix3< T > &m, EulerConvention convention=EulerConvention::Intrinsic)
 An optimized version of rotationMatrixToEuler(m, 2, 1, 0, convention) or rotationMatrixToEuler(m, 0, 1, 2, convention).reverse().
 
template<typename T >
Quaternion< TeulerToQuaternion (const Vector3< T > &angles, int axis0, int axis1, int axis2, EulerConvention convention=EulerConvention::Intrinsic)
 Converts Euler angles to quaternion.
 
template<typename T >
Matrix3< TeulerToRotationMatrix (const Vector3< T > &angles, int axis0, int axis1, int axis2, EulerConvention convention=EulerConvention::Intrinsic)
 Converts Euler angles to rotation matrix.
 
template<typename T >
Matrix3< TeulerXYZToRotationMatrix (const Vector3< T > &angles, EulerConvention convention=EulerConvention::Intrinsic)
 An optimized version of eulerToRotationMatrix(angles, 0, 1, 2, convention) or eulerToRotationMatrix(angles.reverse(), 2, 1, 0, convention).
 
template<typename T >
Matrix3< TeulerZYXToRotationMatrix (const Vector3< T > &angles, EulerConvention convention=EulerConvention::Intrinsic)
 An optimized version of eulerToRotationMatrix(angles, 2, 1, 0, convention) or eulerToRotationMatrix(angles.reverse(), 0, 1, 2, convention).
 
template<typename T >
Vector3< TquaternionToEuler (const Quaternion< T > &q)
 Converts a quaternion to Euler angles using the Extrinsic XYZ convention.
 
Quaternionf quaternionAverage (std::span< const Quaternionf > q, std::span< const float > w=std::vector< float >())
 Computes the weighted average of multiple quaternions.
 
template<typename T >
std::tuple< bool, T, Eigen::Vector2< T > > closestPointsOnSegments (const Eigen::Vector3< T > &o1, const Eigen::Vector3< T > &d1, const Eigen::Vector3< T > &o2, const Eigen::Vector3< T > &d2, T maxDist=std::numeric_limits< T >::max())
 Returns the closest points on two line segments where the line segments are represented in origin and direction.
 
template<typename T >
T rotationMatrixToOneAxisEuler (const Matrix3< T > &m, int axis0)
 Fits a single-axis Euler rotation to a rotation matrix.
 
template<typename T >
Vector2< TrotationMatrixToTwoAxisEuler (const Matrix3< T > &m, int axis0, int axis1)
 Fits a two-axis Euler rotation to a rotation matrix.
 
template<typename T >
Eigen::Matrix< T, 3, 3 > crossProductMatrix (const Eigen::Vector3< T > &v)
 Creates a skew-symmetric matrix for computing cross products.
 

Typedef Documentation

◆ AccelerationSequenceErrorFunction

◆ AccelerationSequenceErrorFunction_const_p

◆ AccelerationSequenceErrorFunction_const_u

◆ AccelerationSequenceErrorFunction_const_w

◆ AccelerationSequenceErrorFunction_p

◆ AccelerationSequenceErrorFunction_u

◆ AccelerationSequenceErrorFunction_w

◆ AccelerationSequenceErrorFunctiond

◆ AccelerationSequenceErrorFunctiond_const_p

◆ AccelerationSequenceErrorFunctiond_const_u

◆ AccelerationSequenceErrorFunctiond_const_w

◆ AccelerationSequenceErrorFunctiond_p

◆ AccelerationSequenceErrorFunctiond_u

◆ AccelerationSequenceErrorFunctiond_w

◆ Affine3

template<typename T >
using momentum::Affine3 = typedef Eigen::Transform<T, 3, Eigen::Affine>

Definition at line 386 of file types.h.

◆ Affine3d

Definition at line 388 of file types.h.

◆ Affine3f

Definition at line 387 of file types.h.

◆ AimData

Definition at line 65 of file fwd.h.

◆ AimData_const_p

Definition at line 71 of file fwd.h.

◆ AimData_const_u

Definition at line 72 of file fwd.h.

◆ AimData_const_w

Definition at line 73 of file fwd.h.

◆ AimData_p

using momentum::AimData_p = typedef ::std::shared_ptr<AimData>

Definition at line 68 of file fwd.h.

◆ AimData_u

using momentum::AimData_u = typedef ::std::unique_ptr<AimData>

Definition at line 69 of file fwd.h.

◆ AimData_w

Definition at line 70 of file fwd.h.

◆ AimDatad

Definition at line 66 of file fwd.h.

◆ AimDatad_const_p

Definition at line 78 of file fwd.h.

◆ AimDatad_const_u

Definition at line 79 of file fwd.h.

◆ AimDatad_const_w

Definition at line 80 of file fwd.h.

◆ AimDatad_p

Definition at line 75 of file fwd.h.

◆ AimDatad_u

Definition at line 76 of file fwd.h.

◆ AimDatad_w

Definition at line 77 of file fwd.h.

◆ AimDirErrorFunction

◆ AimDirErrorFunction_const_p

Definition at line 345 of file fwd.h.

◆ AimDirErrorFunction_const_u

Definition at line 346 of file fwd.h.

◆ AimDirErrorFunction_const_w

Definition at line 347 of file fwd.h.

◆ AimDirErrorFunction_p

Definition at line 342 of file fwd.h.

◆ AimDirErrorFunction_u

Definition at line 343 of file fwd.h.

◆ AimDirErrorFunction_w

Definition at line 344 of file fwd.h.

◆ AimDirErrorFunctiond

◆ AimDirErrorFunctiond_const_p

Definition at line 352 of file fwd.h.

◆ AimDirErrorFunctiond_const_u

Definition at line 353 of file fwd.h.

◆ AimDirErrorFunctiond_const_w

◆ AimDirErrorFunctiond_p

Definition at line 349 of file fwd.h.

◆ AimDirErrorFunctiond_u

Definition at line 350 of file fwd.h.

◆ AimDirErrorFunctiond_w

Definition at line 351 of file fwd.h.

◆ AimDistErrorFunction

◆ AimDistErrorFunction_const_p

Definition at line 364 of file fwd.h.

◆ AimDistErrorFunction_const_u

Definition at line 365 of file fwd.h.

◆ AimDistErrorFunction_const_w

◆ AimDistErrorFunction_p

Definition at line 361 of file fwd.h.

◆ AimDistErrorFunction_u

Definition at line 362 of file fwd.h.

◆ AimDistErrorFunction_w

Definition at line 363 of file fwd.h.

◆ AimDistErrorFunctiond

◆ AimDistErrorFunctiond_const_p

Definition at line 371 of file fwd.h.

◆ AimDistErrorFunctiond_const_u

Definition at line 372 of file fwd.h.

◆ AimDistErrorFunctiond_const_w

◆ AimDistErrorFunctiond_p

Definition at line 368 of file fwd.h.

◆ AimDistErrorFunctiond_u

Definition at line 369 of file fwd.h.

◆ AimDistErrorFunctiond_w

Definition at line 370 of file fwd.h.

◆ AngleAxis

template<typename T >
using momentum::AngleAxis = typedef Eigen::AngleAxis<T>

Definition at line 366 of file types.h.

◆ AngleAxisd

Definition at line 368 of file types.h.

◆ AngleAxisf

Definition at line 367 of file types.h.

◆ BlendShape_const_p

Definition at line 23 of file fwd.h.

◆ BlendShape_const_u

Definition at line 24 of file fwd.h.

◆ BlendShape_const_w

Definition at line 25 of file fwd.h.

◆ BlendShape_p

Definition at line 20 of file fwd.h.

◆ BlendShape_u

Definition at line 21 of file fwd.h.

◆ BlendShape_w

Definition at line 22 of file fwd.h.

◆ BlendShapeBase_const_p

Definition at line 32 of file fwd.h.

◆ BlendShapeBase_const_u

Definition at line 33 of file fwd.h.

◆ BlendShapeBase_const_w

Definition at line 34 of file fwd.h.

◆ BlendShapeBase_p

Definition at line 29 of file fwd.h.

◆ BlendShapeBase_u

Definition at line 30 of file fwd.h.

◆ BlendShapeBase_w

Definition at line 31 of file fwd.h.

◆ BlendWeights

◆ BlendWeightsd

◆ Box

template<typename Scalar , int Dim>
using momentum::Box = typedef Eigen::AlignedBox<Scalar, Dim>

Definition at line 56 of file types.h.

◆ Box2

template<typename T >
using momentum::Box2 = typedef Eigen::AlignedBox<T, 2>

Definition at line 68 of file types.h.

◆ Box2d

Definition at line 75 of file types.h.

◆ Box2f

Definition at line 72 of file types.h.

◆ Box2i

using momentum::Box2i = typedef Box2<std::int32_t>

Definition at line 78 of file types.h.

◆ Box3

template<typename T >
using momentum::Box3 = typedef Eigen::AlignedBox<T, 3>

Definition at line 70 of file types.h.

◆ Box3d

Definition at line 76 of file types.h.

◆ Box3f

Definition at line 73 of file types.h.

◆ Box3i

using momentum::Box3i = typedef Box3<std::int32_t>

Definition at line 79 of file types.h.

◆ Boxd

template<int Dim>
using momentum::Boxd = typedef Eigen::AlignedBox<double, Dim>

Definition at line 62 of file types.h.

◆ Boxf

template<int Dim>
using momentum::Boxf = typedef Eigen::AlignedBox<float, Dim>

Definition at line 59 of file types.h.

◆ Boxi

template<int Dim>
using momentum::Boxi = typedef Eigen::AlignedBox<std::int32_t, Dim>

Definition at line 65 of file types.h.

◆ ByteP

Additional packet types for byte and unsigned integer data.

Definition at line 61 of file simd.h.

◆ Character

Definition at line 74 of file fwd.h.

◆ Character_const_p

Definition at line 80 of file fwd.h.

◆ Character_const_u

Definition at line 81 of file fwd.h.

◆ Character_const_w

Definition at line 82 of file fwd.h.

◆ Character_p

Definition at line 77 of file fwd.h.

◆ Character_u

Definition at line 78 of file fwd.h.

◆ Character_w

Definition at line 79 of file fwd.h.

◆ Characterd

Definition at line 75 of file fwd.h.

◆ Characterd_const_p

Definition at line 87 of file fwd.h.

◆ Characterd_const_u

Definition at line 88 of file fwd.h.

◆ Characterd_const_w

Definition at line 89 of file fwd.h.

◆ Characterd_p

Definition at line 84 of file fwd.h.

◆ Characterd_u

Definition at line 85 of file fwd.h.

◆ Characterd_w

Definition at line 86 of file fwd.h.

◆ CharacterParameters

◆ CharacterParametersd

◆ CharacterState

◆ CharacterState_const_p

Definition at line 99 of file fwd.h.

◆ CharacterState_const_u

Definition at line 100 of file fwd.h.

◆ CharacterState_const_w

Definition at line 101 of file fwd.h.

◆ CharacterState_p

Definition at line 96 of file fwd.h.

◆ CharacterState_u

Definition at line 97 of file fwd.h.

◆ CharacterState_w

Definition at line 98 of file fwd.h.

◆ CharacterStated

◆ CharacterStated_const_p

Definition at line 106 of file fwd.h.

◆ CharacterStated_const_u

Definition at line 107 of file fwd.h.

◆ CharacterStated_const_w

Definition at line 108 of file fwd.h.

◆ CharacterStated_p

Definition at line 103 of file fwd.h.

◆ CharacterStated_u

Definition at line 104 of file fwd.h.

◆ CharacterStated_w

Definition at line 105 of file fwd.h.

◆ CollisionErrorFunction

◆ CollisionErrorFunction_const_p

◆ CollisionErrorFunction_const_u

◆ CollisionErrorFunction_const_w

◆ CollisionErrorFunction_p

Definition at line 380 of file fwd.h.

◆ CollisionErrorFunction_u

Definition at line 381 of file fwd.h.

◆ CollisionErrorFunction_w

Definition at line 382 of file fwd.h.

◆ CollisionErrorFunctiond

◆ CollisionErrorFunctiond_const_p

◆ CollisionErrorFunctiond_const_u

◆ CollisionErrorFunctiond_const_w

◆ CollisionErrorFunctiond_p

Definition at line 387 of file fwd.h.

◆ CollisionErrorFunctiond_u

Definition at line 388 of file fwd.h.

◆ CollisionErrorFunctiond_w

Definition at line 389 of file fwd.h.

◆ CollisionErrorFunctionStateless

◆ CollisionErrorFunctionStateless_const_p

◆ CollisionErrorFunctionStateless_const_u

◆ CollisionErrorFunctionStateless_const_w

◆ CollisionErrorFunctionStateless_p

◆ CollisionErrorFunctionStateless_u

◆ CollisionErrorFunctionStateless_w

◆ CollisionErrorFunctionStatelessd

◆ CollisionErrorFunctionStatelessd_const_p

◆ CollisionErrorFunctionStatelessd_const_u

◆ CollisionErrorFunctionStatelessd_const_w

◆ CollisionErrorFunctionStatelessd_p

◆ CollisionErrorFunctionStatelessd_u

◆ CollisionErrorFunctionStatelessd_w

◆ CollisionGeometry

◆ CollisionGeometryd

◆ CollisionGeometryState

◆ CollisionGeometryState_const_p

◆ CollisionGeometryState_const_u

◆ CollisionGeometryState_const_w

◆ CollisionGeometryState_p

Definition at line 115 of file fwd.h.

◆ CollisionGeometryState_u

Definition at line 116 of file fwd.h.

◆ CollisionGeometryState_w

Definition at line 117 of file fwd.h.

◆ CollisionGeometryStated

◆ CollisionGeometryStated_const_p

◆ CollisionGeometryStated_const_u

◆ CollisionGeometryStated_const_w

◆ CollisionGeometryStated_p

Definition at line 122 of file fwd.h.

◆ CollisionGeometryStated_u

Definition at line 123 of file fwd.h.

◆ CollisionGeometryStated_w

Definition at line 124 of file fwd.h.

◆ CollisionGeometryT

Collection of tapered capsules representing a character's collision geometry.

Definition at line 72 of file collision_geometry.h.

◆ ColorArray

Definition at line 398 of file types.h.

◆ ConstraintData_const_p

Definition at line 23 of file fwd.h.

◆ ConstraintData_const_u

Definition at line 24 of file fwd.h.

◆ ConstraintData_const_w

Definition at line 25 of file fwd.h.

◆ ConstraintData_p

Definition at line 20 of file fwd.h.

◆ ConstraintData_u

Definition at line 21 of file fwd.h.

◆ ConstraintData_w

Definition at line 22 of file fwd.h.

◆ ConstraintDataList

◆ DistanceErrorFunction

◆ DistanceErrorFunction_const_p

Definition at line 427 of file fwd.h.

◆ DistanceErrorFunction_const_u

Definition at line 428 of file fwd.h.

◆ DistanceErrorFunction_const_w

◆ DistanceErrorFunction_p

Definition at line 424 of file fwd.h.

◆ DistanceErrorFunction_u

Definition at line 425 of file fwd.h.

◆ DistanceErrorFunction_w

Definition at line 426 of file fwd.h.

◆ DistanceErrorFunctiond

◆ DistanceErrorFunctiond_const_p

◆ DistanceErrorFunctiond_const_u

◆ DistanceErrorFunctiond_const_w

◆ DistanceErrorFunctiond_p

Definition at line 431 of file fwd.h.

◆ DistanceErrorFunctiond_u

Definition at line 432 of file fwd.h.

◆ DistanceErrorFunctiond_w

Definition at line 433 of file fwd.h.

◆ DoubleP

Definition at line 42 of file simd.h.

◆ ErrorFunctionDerivatives

◆ ErrorFunctionDerivatives_const_p

◆ ErrorFunctionDerivatives_const_u

◆ ErrorFunctionDerivatives_const_w

◆ ErrorFunctionDerivatives_p

Definition at line 23 of file fwd.h.

◆ ErrorFunctionDerivatives_u

Definition at line 24 of file fwd.h.

◆ ErrorFunctionDerivatives_w

Definition at line 25 of file fwd.h.

◆ ErrorFunctionDerivativesd

◆ ErrorFunctionDerivativesd_const_p

◆ ErrorFunctionDerivativesd_const_u

◆ ErrorFunctionDerivativesd_const_w

◆ ErrorFunctionDerivativesd_p

Definition at line 30 of file fwd.h.

◆ ErrorFunctionDerivativesd_u

Definition at line 31 of file fwd.h.

◆ ErrorFunctionDerivativesd_w

Definition at line 32 of file fwd.h.

◆ FiniteDifferenceSequenceErrorFunction

◆ FiniteDifferenceSequenceErrorFunction_const_p

◆ FiniteDifferenceSequenceErrorFunction_const_u

◆ FiniteDifferenceSequenceErrorFunction_const_w

◆ FiniteDifferenceSequenceErrorFunction_p

◆ FiniteDifferenceSequenceErrorFunction_u

◆ FiniteDifferenceSequenceErrorFunction_w

◆ FiniteDifferenceSequenceErrorFunctiond

◆ FiniteDifferenceSequenceErrorFunctiond_const_p

◆ FiniteDifferenceSequenceErrorFunctiond_const_u

◆ FiniteDifferenceSequenceErrorFunctiond_const_w

◆ FiniteDifferenceSequenceErrorFunctiond_p

◆ FiniteDifferenceSequenceErrorFunctiond_u

◆ FiniteDifferenceSequenceErrorFunctiond_w

◆ FixedAxisAngleErrorFunction

◆ FixedAxisAngleErrorFunction_const_p

◆ FixedAxisAngleErrorFunction_const_u

◆ FixedAxisAngleErrorFunction_const_w

◆ FixedAxisAngleErrorFunction_p

◆ FixedAxisAngleErrorFunction_u

◆ FixedAxisAngleErrorFunction_w

◆ FixedAxisAngleErrorFunctiond

◆ FixedAxisAngleErrorFunctiond_const_p

◆ FixedAxisAngleErrorFunctiond_const_u

◆ FixedAxisAngleErrorFunctiond_const_w

◆ FixedAxisAngleErrorFunctiond_p

◆ FixedAxisAngleErrorFunctiond_u

◆ FixedAxisAngleErrorFunctiond_w

◆ FixedAxisCosErrorFunction

◆ FixedAxisCosErrorFunction_const_p

◆ FixedAxisCosErrorFunction_const_u

◆ FixedAxisCosErrorFunction_const_w

◆ FixedAxisCosErrorFunction_p

Definition at line 462 of file fwd.h.

◆ FixedAxisCosErrorFunction_u

Definition at line 463 of file fwd.h.

◆ FixedAxisCosErrorFunction_w

◆ FixedAxisCosErrorFunctiond

◆ FixedAxisCosErrorFunctiond_const_p

◆ FixedAxisCosErrorFunctiond_const_u

◆ FixedAxisCosErrorFunctiond_const_w

◆ FixedAxisCosErrorFunctiond_p

Definition at line 469 of file fwd.h.

◆ FixedAxisCosErrorFunctiond_u

Definition at line 470 of file fwd.h.

◆ FixedAxisCosErrorFunctiond_w

◆ FixedAxisData

◆ FixedAxisData_const_p

Definition at line 90 of file fwd.h.

◆ FixedAxisData_const_u

Definition at line 91 of file fwd.h.

◆ FixedAxisData_const_w

Definition at line 92 of file fwd.h.

◆ FixedAxisData_p

Definition at line 87 of file fwd.h.

◆ FixedAxisData_u

Definition at line 88 of file fwd.h.

◆ FixedAxisData_w

Definition at line 89 of file fwd.h.

◆ FixedAxisDatad

◆ FixedAxisDatad_const_p

Definition at line 97 of file fwd.h.

◆ FixedAxisDatad_const_u

Definition at line 98 of file fwd.h.

◆ FixedAxisDatad_const_w

Definition at line 99 of file fwd.h.

◆ FixedAxisDatad_p

Definition at line 94 of file fwd.h.

◆ FixedAxisDatad_u

Definition at line 95 of file fwd.h.

◆ FixedAxisDatad_w

Definition at line 96 of file fwd.h.

◆ FixedAxisDiffErrorFunction

◆ FixedAxisDiffErrorFunction_const_p

◆ FixedAxisDiffErrorFunction_const_u

◆ FixedAxisDiffErrorFunction_const_w

◆ FixedAxisDiffErrorFunction_p

Definition at line 481 of file fwd.h.

◆ FixedAxisDiffErrorFunction_u

Definition at line 482 of file fwd.h.

◆ FixedAxisDiffErrorFunction_w

◆ FixedAxisDiffErrorFunctiond

◆ FixedAxisDiffErrorFunctiond_const_p

◆ FixedAxisDiffErrorFunctiond_const_u

◆ FixedAxisDiffErrorFunctiond_const_w

◆ FixedAxisDiffErrorFunctiond_p

◆ FixedAxisDiffErrorFunctiond_u

◆ FixedAxisDiffErrorFunctiond_w

◆ FloatP

Definition at line 41 of file simd.h.

◆ FullyDifferentiableDistanceErrorFunction

◆ FullyDifferentiableDistanceErrorFunction_const_p

◆ FullyDifferentiableDistanceErrorFunction_const_u

◆ FullyDifferentiableDistanceErrorFunction_const_w

◆ FullyDifferentiableDistanceErrorFunction_p

◆ FullyDifferentiableDistanceErrorFunction_u

◆ FullyDifferentiableDistanceErrorFunction_w

◆ FullyDifferentiableDistanceErrorFunctiond

◆ FullyDifferentiableDistanceErrorFunctiond_const_p

◆ FullyDifferentiableDistanceErrorFunctiond_const_u

◆ FullyDifferentiableDistanceErrorFunctiond_const_w

◆ FullyDifferentiableDistanceErrorFunctiond_p

◆ FullyDifferentiableDistanceErrorFunctiond_u

◆ FullyDifferentiableDistanceErrorFunctiond_w

◆ FullyDifferentiableMotionErrorFunction

◆ FullyDifferentiableMotionErrorFunction_const_p

◆ FullyDifferentiableMotionErrorFunction_const_u

◆ FullyDifferentiableMotionErrorFunction_const_w

◆ FullyDifferentiableMotionErrorFunction_p

◆ FullyDifferentiableMotionErrorFunction_u

◆ FullyDifferentiableMotionErrorFunction_w

◆ FullyDifferentiableMotionErrorFunctiond

◆ FullyDifferentiableMotionErrorFunctiond_const_p

◆ FullyDifferentiableMotionErrorFunctiond_const_u

◆ FullyDifferentiableMotionErrorFunctiond_const_w

◆ FullyDifferentiableMotionErrorFunctiond_p

◆ FullyDifferentiableMotionErrorFunctiond_u

◆ FullyDifferentiableMotionErrorFunctiond_w

◆ FullyDifferentiableOrientationErrorFunction

◆ FullyDifferentiableOrientationErrorFunction_const_p

◆ FullyDifferentiableOrientationErrorFunction_const_u

◆ FullyDifferentiableOrientationErrorFunction_const_w

◆ FullyDifferentiableOrientationErrorFunction_p

◆ FullyDifferentiableOrientationErrorFunction_u

◆ FullyDifferentiableOrientationErrorFunction_w

◆ FullyDifferentiableOrientationErrorFunctiond

◆ FullyDifferentiableOrientationErrorFunctiond_const_p

◆ FullyDifferentiableOrientationErrorFunctiond_const_u

◆ FullyDifferentiableOrientationErrorFunctiond_const_w

◆ FullyDifferentiableOrientationErrorFunctiond_p

◆ FullyDifferentiableOrientationErrorFunctiond_u

◆ FullyDifferentiableOrientationErrorFunctiond_w

◆ FullyDifferentiablePosePriorErrorFunction

◆ FullyDifferentiablePosePriorErrorFunction_const_p

◆ FullyDifferentiablePosePriorErrorFunction_const_u

◆ FullyDifferentiablePosePriorErrorFunction_const_w

◆ FullyDifferentiablePosePriorErrorFunction_p

◆ FullyDifferentiablePosePriorErrorFunction_u

◆ FullyDifferentiablePosePriorErrorFunction_w

◆ FullyDifferentiablePosePriorErrorFunctiond

◆ FullyDifferentiablePosePriorErrorFunctiond_const_p

◆ FullyDifferentiablePosePriorErrorFunctiond_const_u

◆ FullyDifferentiablePosePriorErrorFunctiond_const_w

◆ FullyDifferentiablePosePriorErrorFunctiond_p

◆ FullyDifferentiablePosePriorErrorFunctiond_u

◆ FullyDifferentiablePosePriorErrorFunctiond_w

◆ FullyDifferentiablePositionErrorFunction

◆ FullyDifferentiablePositionErrorFunction_const_p

◆ FullyDifferentiablePositionErrorFunction_const_u

◆ FullyDifferentiablePositionErrorFunction_const_w

◆ FullyDifferentiablePositionErrorFunction_p

◆ FullyDifferentiablePositionErrorFunction_u

◆ FullyDifferentiablePositionErrorFunction_w

◆ FullyDifferentiablePositionErrorFunctiond

◆ FullyDifferentiablePositionErrorFunctiond_const_p

◆ FullyDifferentiablePositionErrorFunctiond_const_u

◆ FullyDifferentiablePositionErrorFunctiond_const_w

◆ FullyDifferentiablePositionErrorFunctiond_p

◆ FullyDifferentiablePositionErrorFunctiond_u

◆ FullyDifferentiablePositionErrorFunctiond_w

◆ FullyDifferentiableProjectionErrorFunction

◆ FullyDifferentiableProjectionErrorFunction_const_p

◆ FullyDifferentiableProjectionErrorFunction_const_u

◆ FullyDifferentiableProjectionErrorFunction_const_w

◆ FullyDifferentiableProjectionErrorFunction_p

◆ FullyDifferentiableProjectionErrorFunction_u

◆ FullyDifferentiableProjectionErrorFunction_w

◆ FullyDifferentiableProjectionErrorFunctiond

◆ FullyDifferentiableProjectionErrorFunctiond_const_p

◆ FullyDifferentiableProjectionErrorFunctiond_const_u

◆ FullyDifferentiableProjectionErrorFunctiond_const_w

◆ FullyDifferentiableProjectionErrorFunctiond_p

◆ FullyDifferentiableProjectionErrorFunctiond_u

◆ FullyDifferentiableProjectionErrorFunctiond_w

◆ FullyDifferentiableSkeletonErrorFunction

◆ FullyDifferentiableSkeletonErrorFunction_const_p

◆ FullyDifferentiableSkeletonErrorFunction_const_u

◆ FullyDifferentiableSkeletonErrorFunction_const_w

◆ FullyDifferentiableSkeletonErrorFunction_p

◆ FullyDifferentiableSkeletonErrorFunction_u

◆ FullyDifferentiableSkeletonErrorFunction_w

◆ FullyDifferentiableSkeletonErrorFunctiond

◆ FullyDifferentiableSkeletonErrorFunctiond_const_p

◆ FullyDifferentiableSkeletonErrorFunctiond_const_u

◆ FullyDifferentiableSkeletonErrorFunctiond_const_w

◆ FullyDifferentiableSkeletonErrorFunctiond_p

◆ FullyDifferentiableSkeletonErrorFunctiond_u

◆ FullyDifferentiableSkeletonErrorFunctiond_w

◆ FullyDifferentiableStateErrorFunction

◆ FullyDifferentiableStateErrorFunction_const_p

◆ FullyDifferentiableStateErrorFunction_const_u

◆ FullyDifferentiableStateErrorFunction_const_w

◆ FullyDifferentiableStateErrorFunction_p

◆ FullyDifferentiableStateErrorFunction_u

◆ FullyDifferentiableStateErrorFunction_w

◆ FullyDifferentiableStateErrorFunctiond

◆ FullyDifferentiableStateErrorFunctiond_const_p

◆ FullyDifferentiableStateErrorFunctiond_const_u

◆ FullyDifferentiableStateErrorFunctiond_const_w

◆ FullyDifferentiableStateErrorFunctiond_p

◆ FullyDifferentiableStateErrorFunctiond_u

◆ FullyDifferentiableStateErrorFunctiond_w

◆ GaussNewtonSolver

◆ GaussNewtonSolver_const_p

Definition at line 94 of file fwd.h.

◆ GaussNewtonSolver_const_u

Definition at line 95 of file fwd.h.

◆ GaussNewtonSolver_const_w

Definition at line 96 of file fwd.h.

◆ GaussNewtonSolver_p

Definition at line 91 of file fwd.h.

◆ GaussNewtonSolver_u

Definition at line 92 of file fwd.h.

◆ GaussNewtonSolver_w

Definition at line 93 of file fwd.h.

◆ GaussNewtonSolverd

◆ GaussNewtonSolverd_const_p

Definition at line 101 of file fwd.h.

◆ GaussNewtonSolverd_const_u

Definition at line 102 of file fwd.h.

◆ GaussNewtonSolverd_const_w

Definition at line 103 of file fwd.h.

◆ GaussNewtonSolverd_p

Definition at line 98 of file fwd.h.

◆ GaussNewtonSolverd_u

Definition at line 99 of file fwd.h.

◆ GaussNewtonSolverd_w

Definition at line 100 of file fwd.h.

◆ GaussNewtonSolverOptions_const_p

◆ GaussNewtonSolverOptions_const_u

◆ GaussNewtonSolverOptions_const_w

◆ GaussNewtonSolverOptions_p

Definition at line 29 of file fwd.h.

◆ GaussNewtonSolverOptions_u

Definition at line 30 of file fwd.h.

◆ GaussNewtonSolverOptions_w

Definition at line 31 of file fwd.h.

◆ GaussNewtonSolverQR

◆ GaussNewtonSolverQR_const_p

Definition at line 503 of file fwd.h.

◆ GaussNewtonSolverQR_const_u

Definition at line 504 of file fwd.h.

◆ GaussNewtonSolverQR_const_w

Definition at line 505 of file fwd.h.

◆ GaussNewtonSolverQR_p

Definition at line 500 of file fwd.h.

◆ GaussNewtonSolverQR_u

Definition at line 501 of file fwd.h.

◆ GaussNewtonSolverQR_w

Definition at line 502 of file fwd.h.

◆ GaussNewtonSolverQRd

◆ GaussNewtonSolverQRd_const_p

Definition at line 510 of file fwd.h.

◆ GaussNewtonSolverQRd_const_u

Definition at line 511 of file fwd.h.

◆ GaussNewtonSolverQRd_const_w

◆ GaussNewtonSolverQRd_p

Definition at line 507 of file fwd.h.

◆ GaussNewtonSolverQRd_u

Definition at line 508 of file fwd.h.

◆ GaussNewtonSolverQRd_w

Definition at line 509 of file fwd.h.

◆ GaussNewtonSolverQROptions_const_p

◆ GaussNewtonSolverQROptions_const_u

◆ GaussNewtonSolverQROptions_const_w

◆ GaussNewtonSolverQROptions_p

Definition at line 29 of file fwd.h.

◆ GaussNewtonSolverQROptions_u

Definition at line 30 of file fwd.h.

◆ GaussNewtonSolverQROptions_w

◆ GeneralizedLoss

◆ GeneralizedLoss_const_p

Definition at line 102 of file fwd.h.

◆ GeneralizedLoss_const_u

Definition at line 103 of file fwd.h.

◆ GeneralizedLoss_const_w

Definition at line 104 of file fwd.h.

◆ GeneralizedLoss_p

Definition at line 99 of file fwd.h.

◆ GeneralizedLoss_u

Definition at line 100 of file fwd.h.

◆ GeneralizedLoss_w

Definition at line 101 of file fwd.h.

◆ GeneralizedLossd

◆ GeneralizedLossd_const_p

Definition at line 109 of file fwd.h.

◆ GeneralizedLossd_const_u

Definition at line 110 of file fwd.h.

◆ GeneralizedLossd_const_w

Definition at line 111 of file fwd.h.

◆ GeneralizedLossd_p

Definition at line 106 of file fwd.h.

◆ GeneralizedLossd_u

Definition at line 107 of file fwd.h.

◆ GeneralizedLossd_w

Definition at line 108 of file fwd.h.

◆ GradientDescentSolver

◆ GradientDescentSolver_const_p

Definition at line 132 of file fwd.h.

◆ GradientDescentSolver_const_u

Definition at line 133 of file fwd.h.

◆ GradientDescentSolver_const_w

◆ GradientDescentSolver_p

Definition at line 129 of file fwd.h.

◆ GradientDescentSolver_u

Definition at line 130 of file fwd.h.

◆ GradientDescentSolver_w

Definition at line 131 of file fwd.h.

◆ GradientDescentSolverd

◆ GradientDescentSolverd_const_p

◆ GradientDescentSolverd_const_u

◆ GradientDescentSolverd_const_w

◆ GradientDescentSolverd_p

Definition at line 136 of file fwd.h.

◆ GradientDescentSolverd_u

Definition at line 137 of file fwd.h.

◆ GradientDescentSolverd_w

Definition at line 138 of file fwd.h.

◆ HeightErrorFunction

◆ HeightErrorFunction_const_p

Definition at line 522 of file fwd.h.

◆ HeightErrorFunction_const_u

Definition at line 523 of file fwd.h.

◆ HeightErrorFunction_const_w

Definition at line 524 of file fwd.h.

◆ HeightErrorFunction_p

Definition at line 519 of file fwd.h.

◆ HeightErrorFunction_u

Definition at line 520 of file fwd.h.

◆ HeightErrorFunction_w

Definition at line 521 of file fwd.h.

◆ HeightErrorFunctiond

◆ HeightErrorFunctiond_const_p

Definition at line 529 of file fwd.h.

◆ HeightErrorFunctiond_const_u

Definition at line 530 of file fwd.h.

◆ HeightErrorFunctiond_const_w

◆ HeightErrorFunctiond_p

Definition at line 526 of file fwd.h.

◆ HeightErrorFunctiond_u

Definition at line 527 of file fwd.h.

◆ HeightErrorFunctiond_w

Definition at line 528 of file fwd.h.

◆ IdentityParameters

typedef std::tuple< std::vector< std::string >, JointParameters > momentum::IdentityParameters

Definition at line 197 of file types.h.

◆ IndexMatrix

using momentum::IndexMatrix = typedef Eigen::Matrix<uint32_t, Eigen::Dynamic, kMaxSkinJoints, Eigen::AutoAlign | Eigen::RowMajor>

Matrix type for storing joint indices that influence each vertex.

Each row represents a vertex, and each column represents a joint influence. The matrix has a fixed number of columns (kMaxSkinJoints) and a dynamic number of rows.

Definition at line 25 of file skin_weights.h.

◆ IntP

Definition at line 43 of file simd.h.

◆ InverseParameterTransform

◆ InverseParameterTransformd

◆ Isometry3

template<typename T >
using momentum::Isometry3 = typedef Eigen::Transform<T, 3, Eigen::Isometry>

Definition at line 381 of file types.h.

◆ Isometry3d

Definition at line 383 of file types.h.

◆ Isometry3f

Definition at line 382 of file types.h.

◆ JerkSequenceErrorFunction

◆ JerkSequenceErrorFunction_const_p

◆ JerkSequenceErrorFunction_const_u

◆ JerkSequenceErrorFunction_const_w

◆ JerkSequenceErrorFunction_p

Definition at line 97 of file fwd.h.

◆ JerkSequenceErrorFunction_u

Definition at line 98 of file fwd.h.

◆ JerkSequenceErrorFunction_w

Definition at line 99 of file fwd.h.

◆ JerkSequenceErrorFunctiond

◆ JerkSequenceErrorFunctiond_const_p

◆ JerkSequenceErrorFunctiond_const_u

◆ JerkSequenceErrorFunctiond_const_w

◆ JerkSequenceErrorFunctiond_p

Definition at line 104 of file fwd.h.

◆ JerkSequenceErrorFunctiond_u

Definition at line 105 of file fwd.h.

◆ JerkSequenceErrorFunctiond_w

◆ Joint

Definition at line 131 of file fwd.h.

◆ Joint_const_p

Definition at line 137 of file fwd.h.

◆ Joint_const_u

Definition at line 138 of file fwd.h.

◆ Joint_const_w

Definition at line 139 of file fwd.h.

◆ Joint_p

using momentum::Joint_p = typedef ::std::shared_ptr<Joint>

Definition at line 134 of file fwd.h.

◆ Joint_u

using momentum::Joint_u = typedef ::std::unique_ptr<Joint>

Definition at line 135 of file fwd.h.

◆ Joint_w

using momentum::Joint_w = typedef ::std::weak_ptr<Joint>

Definition at line 136 of file fwd.h.

◆ Jointd

Definition at line 132 of file fwd.h.

◆ Jointd_const_p

Definition at line 144 of file fwd.h.

◆ Jointd_const_u

Definition at line 145 of file fwd.h.

◆ Jointd_const_w

Definition at line 146 of file fwd.h.

◆ Jointd_p

using momentum::Jointd_p = typedef ::std::shared_ptr<Jointd>

Definition at line 141 of file fwd.h.

◆ Jointd_u

using momentum::Jointd_u = typedef ::std::unique_ptr<Jointd>

Definition at line 142 of file fwd.h.

◆ Jointd_w

using momentum::Jointd_w = typedef ::std::weak_ptr<Jointd>

Definition at line 143 of file fwd.h.

◆ JointList

Definition at line 79 of file joint.h.

◆ JointListd

Definition at line 80 of file joint.h.

◆ JointListT

template<typename T >
using momentum::JointListT = typedef std::vector<JointT<T> >

A list of joints (e.g., of a skeleton).

Definition at line 78 of file joint.h.

◆ JointParameters

◆ JointParametersd

◆ JointState

Definition at line 150 of file fwd.h.

◆ JointState_const_p

Definition at line 156 of file fwd.h.

◆ JointState_const_u

Definition at line 157 of file fwd.h.

◆ JointState_const_w

Definition at line 158 of file fwd.h.

◆ JointState_p

Definition at line 153 of file fwd.h.

◆ JointState_u

Definition at line 154 of file fwd.h.

◆ JointState_w

Definition at line 155 of file fwd.h.

◆ JointStated

Definition at line 151 of file fwd.h.

◆ JointStated_const_p

Definition at line 163 of file fwd.h.

◆ JointStated_const_u

Definition at line 164 of file fwd.h.

◆ JointStated_const_w

Definition at line 165 of file fwd.h.

◆ JointStated_p

Definition at line 160 of file fwd.h.

◆ JointStated_u

Definition at line 161 of file fwd.h.

◆ JointStated_w

Definition at line 162 of file fwd.h.

◆ JointStateList

◆ JointStateListd

◆ JointStateListT

Structure describing the state of all joints in a skeleton.

Definition at line 236 of file joint_state.h.

◆ JointVector

◆ JointVectorT

Definition at line 31 of file types.h.

◆ LimitErrorFunction

◆ LimitErrorFunction_const_p

Definition at line 541 of file fwd.h.

◆ LimitErrorFunction_const_u

Definition at line 542 of file fwd.h.

◆ LimitErrorFunction_const_w

Definition at line 543 of file fwd.h.

◆ LimitErrorFunction_p

Definition at line 538 of file fwd.h.

◆ LimitErrorFunction_u

Definition at line 539 of file fwd.h.

◆ LimitErrorFunction_w

Definition at line 540 of file fwd.h.

◆ LimitErrorFunctiond

◆ LimitErrorFunctiond_const_p

Definition at line 548 of file fwd.h.

◆ LimitErrorFunctiond_const_u

Definition at line 549 of file fwd.h.

◆ LimitErrorFunctiond_const_w

Definition at line 550 of file fwd.h.

◆ LimitErrorFunctiond_p

Definition at line 545 of file fwd.h.

◆ LimitErrorFunctiond_u

Definition at line 546 of file fwd.h.

◆ LimitErrorFunctiond_w

Definition at line 547 of file fwd.h.

◆ Line

template<typename Scalar , int Dim>
using momentum::Line = typedef Eigen::ParametrizedLine<Scalar, Dim>

Definition at line 50 of file types.h.

◆ Locator_const_p

Definition at line 41 of file fwd.h.

◆ Locator_const_u

Definition at line 42 of file fwd.h.

◆ Locator_const_w

Definition at line 43 of file fwd.h.

◆ Locator_p

using momentum::Locator_p = typedef ::std::shared_ptr<Locator>

Definition at line 38 of file fwd.h.

◆ Locator_u

using momentum::Locator_u = typedef ::std::unique_ptr<Locator>

Definition at line 39 of file fwd.h.

◆ Locator_w

Definition at line 40 of file fwd.h.

◆ LocatorList

A collection of locators attached to a skeleton.

Definition at line 92 of file locator.h.

◆ LowRankCovarianceMatrix

◆ LowRankCovarianceMatrix_const_p

◆ LowRankCovarianceMatrix_const_u

◆ LowRankCovarianceMatrix_const_w

◆ LowRankCovarianceMatrix_p

Definition at line 80 of file fwd.h.

◆ LowRankCovarianceMatrix_u

Definition at line 81 of file fwd.h.

◆ LowRankCovarianceMatrix_w

Definition at line 82 of file fwd.h.

◆ LowRankCovarianceMatrixd

◆ LowRankCovarianceMatrixd_const_p

◆ LowRankCovarianceMatrixd_const_u

◆ LowRankCovarianceMatrixd_const_w

◆ LowRankCovarianceMatrixd_p

Definition at line 87 of file fwd.h.

◆ LowRankCovarianceMatrixd_u

Definition at line 88 of file fwd.h.

◆ LowRankCovarianceMatrixd_w

Definition at line 89 of file fwd.h.

◆ Map

template<class T >
using momentum::Map = typedef Eigen::Map<T>

Definition at line 44 of file types.h.

◆ Matrix0

template<typename T >
using momentum::Matrix0 = typedef Eigen::Matrix<T, 0, 0>

Definition at line 92 of file types.h.

◆ Matrix0b

Definition at line 122 of file types.h.

◆ Matrix0d

Definition at line 114 of file types.h.

◆ Matrix0f

Definition at line 106 of file types.h.

◆ Matrix0i

Definition at line 146 of file types.h.

◆ Matrix0s

Definition at line 130 of file types.h.

◆ Matrix0u

Definition at line 138 of file types.h.

◆ Matrix1

template<typename T >
using momentum::Matrix1 = typedef Eigen::Matrix<T, 1, 1>

Definition at line 94 of file types.h.

◆ Matrix1b

Definition at line 123 of file types.h.

◆ Matrix1d

Definition at line 115 of file types.h.

◆ Matrix1f

Definition at line 107 of file types.h.

◆ Matrix1i

Definition at line 147 of file types.h.

◆ Matrix1s

Definition at line 131 of file types.h.

◆ Matrix1u

Definition at line 139 of file types.h.

◆ Matrix2

template<typename T >
using momentum::Matrix2 = typedef Eigen::Matrix<T, 2, 2>

Definition at line 96 of file types.h.

◆ Matrix2b

Definition at line 124 of file types.h.

◆ Matrix2d

Definition at line 116 of file types.h.

◆ Matrix2f

Definition at line 108 of file types.h.

◆ Matrix2i

Definition at line 148 of file types.h.

◆ Matrix2s

Definition at line 132 of file types.h.

◆ Matrix2u

Definition at line 140 of file types.h.

◆ Matrix3

template<typename T >
using momentum::Matrix3 = typedef Eigen::Matrix<T, 3, 3>

Definition at line 98 of file types.h.

◆ Matrix3b

Definition at line 125 of file types.h.

◆ Matrix3d

Definition at line 117 of file types.h.

◆ Matrix3dP

Definition at line 87 of file simd.h.

◆ Matrix3f

Definition at line 109 of file types.h.

◆ Matrix3fP

Definition at line 86 of file simd.h.

◆ Matrix3i

Definition at line 149 of file types.h.

◆ Matrix3P

Definition at line 81 of file simd.h.

◆ Matrix3s

Definition at line 133 of file types.h.

◆ Matrix3u

Definition at line 141 of file types.h.

◆ Matrix3X

template<typename T >
using momentum::Matrix3X = typedef Eigen::Matrix<T, 3, Dynamic>

Definition at line 155 of file types.h.

◆ Matrix3Xb

Definition at line 158 of file types.h.

◆ Matrix3Xd

Definition at line 157 of file types.h.

◆ Matrix3Xf

Definition at line 156 of file types.h.

◆ Matrix3Xi

Definition at line 161 of file types.h.

◆ Matrix3Xs

Definition at line 159 of file types.h.

◆ Matrix3Xu

Definition at line 160 of file types.h.

◆ Matrix4

template<typename T >
using momentum::Matrix4 = typedef Eigen::Matrix<T, 4, 4>

Definition at line 100 of file types.h.

◆ Matrix4b

Definition at line 126 of file types.h.

◆ Matrix4d

Definition at line 118 of file types.h.

◆ Matrix4dP

Definition at line 89 of file simd.h.

◆ Matrix4f

Definition at line 110 of file types.h.

◆ Matrix4fP

Definition at line 88 of file simd.h.

◆ Matrix4i

Definition at line 150 of file types.h.

◆ Matrix4P

Definition at line 84 of file simd.h.

◆ Matrix4s

Definition at line 134 of file types.h.

◆ Matrix4u

Definition at line 142 of file types.h.

◆ Matrix5

template<typename T >
using momentum::Matrix5 = typedef Eigen::Matrix<T, 5, 5>

Definition at line 102 of file types.h.

◆ Matrix5b

Definition at line 127 of file types.h.

◆ Matrix5d

Definition at line 119 of file types.h.

◆ Matrix5f

Definition at line 111 of file types.h.

◆ Matrix5i

Definition at line 151 of file types.h.

◆ Matrix5s

Definition at line 135 of file types.h.

◆ Matrix5u

Definition at line 143 of file types.h.

◆ Matrix6

template<typename T >
using momentum::Matrix6 = typedef Eigen::Matrix<T, 6, 6>

Definition at line 104 of file types.h.

◆ Matrix6b

Definition at line 128 of file types.h.

◆ Matrix6d

Definition at line 120 of file types.h.

◆ Matrix6f

Definition at line 112 of file types.h.

◆ Matrix6i

Definition at line 152 of file types.h.

◆ Matrix6s

Definition at line 136 of file types.h.

◆ Matrix6u

Definition at line 144 of file types.h.

◆ MatrixP

template<typename T , int Dim>
using momentum::MatrixP = typedef drjit::Matrix<Packet<T>, Dim>

Matrix types for SIMD packets.

Definition at line 78 of file simd.h.

◆ MatrixX

template<typename T >
using momentum::MatrixX = typedef Eigen::Matrix<T, Dynamic, Dynamic>

Definition at line 82 of file types.h.

◆ MatrixX3

template<typename T >
using momentum::MatrixX3 = typedef Eigen::Matrix<T, Dynamic, 3>

Definition at line 164 of file types.h.

◆ MatrixX3b

Definition at line 167 of file types.h.

◆ MatrixX3d

Definition at line 166 of file types.h.

◆ MatrixX3f

Definition at line 165 of file types.h.

◆ MatrixX3i

Definition at line 170 of file types.h.

◆ MatrixX3s

Definition at line 168 of file types.h.

◆ MatrixX3u

Definition at line 169 of file types.h.

◆ MatrixXb

Definition at line 86 of file types.h.

◆ MatrixXd

Definition at line 85 of file types.h.

◆ MatrixXf

Definition at line 84 of file types.h.

◆ MatrixXi

Definition at line 89 of file types.h.

◆ MatrixXs

Definition at line 87 of file types.h.

◆ MatrixXu

Definition at line 88 of file types.h.

◆ Mesh

Definition at line 20 of file fwd.h.

◆ Mesh_const_p

Definition at line 26 of file fwd.h.

◆ Mesh_const_u

Definition at line 27 of file fwd.h.

◆ Mesh_const_w

Definition at line 28 of file fwd.h.

◆ Mesh_p

using momentum::Mesh_p = typedef ::std::shared_ptr<Mesh>

Definition at line 23 of file fwd.h.

◆ Mesh_u

using momentum::Mesh_u = typedef ::std::unique_ptr<Mesh>

Definition at line 24 of file fwd.h.

◆ Mesh_w

using momentum::Mesh_w = typedef ::std::weak_ptr<Mesh>

Definition at line 25 of file fwd.h.

◆ Meshd

Definition at line 21 of file fwd.h.

◆ Meshd_const_p

Definition at line 33 of file fwd.h.

◆ Meshd_const_u

Definition at line 34 of file fwd.h.

◆ Meshd_const_w

Definition at line 35 of file fwd.h.

◆ Meshd_p

using momentum::Meshd_p = typedef ::std::shared_ptr<Meshd>

Definition at line 30 of file fwd.h.

◆ Meshd_u

using momentum::Meshd_u = typedef ::std::unique_ptr<Meshd>

Definition at line 31 of file fwd.h.

◆ Meshd_w

using momentum::Meshd_w = typedef ::std::weak_ptr<Meshd>

Definition at line 32 of file fwd.h.

◆ MeshState

Definition at line 226 of file fwd.h.

◆ MeshState_const_p

Definition at line 232 of file fwd.h.

◆ MeshState_const_u

Definition at line 233 of file fwd.h.

◆ MeshState_const_w

Definition at line 234 of file fwd.h.

◆ MeshState_p

Definition at line 229 of file fwd.h.

◆ MeshState_u

Definition at line 230 of file fwd.h.

◆ MeshState_w

Definition at line 231 of file fwd.h.

◆ MeshStated

Definition at line 227 of file fwd.h.

◆ MeshStated_const_p

Definition at line 239 of file fwd.h.

◆ MeshStated_const_u

Definition at line 240 of file fwd.h.

◆ MeshStated_const_w

Definition at line 241 of file fwd.h.

◆ MeshStated_p

Definition at line 236 of file fwd.h.

◆ MeshStated_u

Definition at line 237 of file fwd.h.

◆ MeshStated_w

Definition at line 238 of file fwd.h.

◆ ModelParameters

◆ ModelParametersd

◆ ModelParametersErrorFunction

◆ ModelParametersErrorFunction_const_p

◆ ModelParametersErrorFunction_const_u

◆ ModelParametersErrorFunction_const_w

◆ ModelParametersErrorFunction_p

◆ ModelParametersErrorFunction_u

◆ ModelParametersErrorFunction_w

◆ ModelParametersErrorFunctiond

◆ ModelParametersErrorFunctiond_const_p

◆ ModelParametersErrorFunctiond_const_u

◆ ModelParametersErrorFunctiond_const_w

◆ ModelParametersErrorFunctiond_p

◆ ModelParametersErrorFunctiond_u

◆ ModelParametersErrorFunctiond_w

◆ ModelParametersSequenceErrorFunction

◆ ModelParametersSequenceErrorFunction_const_p

◆ ModelParametersSequenceErrorFunction_const_u

◆ ModelParametersSequenceErrorFunction_const_w

◆ ModelParametersSequenceErrorFunction_p

◆ ModelParametersSequenceErrorFunction_u

◆ ModelParametersSequenceErrorFunction_w

◆ ModelParametersSequenceErrorFunctiond

◆ ModelParametersSequenceErrorFunctiond_const_p

◆ ModelParametersSequenceErrorFunctiond_const_u

◆ ModelParametersSequenceErrorFunctiond_const_w

◆ ModelParametersSequenceErrorFunctiond_p

◆ ModelParametersSequenceErrorFunctiond_u

◆ ModelParametersSequenceErrorFunctiond_w

◆ MotionParameters

typedef std::tuple< std::vector< std::string >, MatrixXf > momentum::MotionParameters

Definition at line 190 of file types.h.

◆ Mppca

Definition at line 39 of file fwd.h.

◆ Mppca_const_p

Definition at line 45 of file fwd.h.

◆ Mppca_const_u

Definition at line 46 of file fwd.h.

◆ Mppca_const_w

Definition at line 47 of file fwd.h.

◆ Mppca_p

using momentum::Mppca_p = typedef ::std::shared_ptr<Mppca>

Definition at line 42 of file fwd.h.

◆ Mppca_u

using momentum::Mppca_u = typedef ::std::unique_ptr<Mppca>

Definition at line 43 of file fwd.h.

◆ Mppca_w

using momentum::Mppca_w = typedef ::std::weak_ptr<Mppca>

Definition at line 44 of file fwd.h.

◆ Mppcad

Definition at line 40 of file fwd.h.

◆ Mppcad_const_p

Definition at line 52 of file fwd.h.

◆ Mppcad_const_u

Definition at line 53 of file fwd.h.

◆ Mppcad_const_w

Definition at line 54 of file fwd.h.

◆ Mppcad_p

using momentum::Mppcad_p = typedef ::std::shared_ptr<Mppcad>

Definition at line 49 of file fwd.h.

◆ Mppcad_u

using momentum::Mppcad_u = typedef ::std::unique_ptr<Mppcad>

Definition at line 50 of file fwd.h.

◆ Mppcad_w

using momentum::Mppcad_w = typedef ::std::weak_ptr<Mppcad>

Definition at line 51 of file fwd.h.

◆ MultiposeSolver

◆ MultiposeSolver_const_p

Definition at line 169 of file fwd.h.

◆ MultiposeSolver_const_u

Definition at line 170 of file fwd.h.

◆ MultiposeSolver_const_w

Definition at line 171 of file fwd.h.

◆ MultiposeSolver_p

Definition at line 166 of file fwd.h.

◆ MultiposeSolver_u

Definition at line 167 of file fwd.h.

◆ MultiposeSolver_w

Definition at line 168 of file fwd.h.

◆ MultiposeSolverd

◆ MultiposeSolverd_const_p

Definition at line 176 of file fwd.h.

◆ MultiposeSolverd_const_u

Definition at line 177 of file fwd.h.

◆ MultiposeSolverd_const_w

Definition at line 178 of file fwd.h.

◆ MultiposeSolverd_p

Definition at line 173 of file fwd.h.

◆ MultiposeSolverd_u

Definition at line 174 of file fwd.h.

◆ MultiposeSolverd_w

Definition at line 175 of file fwd.h.

◆ MultiposeSolverFunction

◆ MultiposeSolverFunction_const_p

◆ MultiposeSolverFunction_const_u

◆ MultiposeSolverFunction_const_w

◆ MultiposeSolverFunction_p

Definition at line 185 of file fwd.h.

◆ MultiposeSolverFunction_u

Definition at line 186 of file fwd.h.

◆ MultiposeSolverFunction_w

Definition at line 187 of file fwd.h.

◆ MultiposeSolverFunctiond

◆ MultiposeSolverFunctiond_const_p

◆ MultiposeSolverFunctiond_const_u

◆ MultiposeSolverFunctiond_const_w

◆ MultiposeSolverFunctiond_p

Definition at line 192 of file fwd.h.

◆ MultiposeSolverFunctiond_u

Definition at line 193 of file fwd.h.

◆ MultiposeSolverFunctiond_w

Definition at line 194 of file fwd.h.

◆ MultiposeSolverOptions_const_p

◆ MultiposeSolverOptions_const_u

◆ MultiposeSolverOptions_const_w

◆ MultiposeSolverOptions_p

Definition at line 20 of file fwd.h.

◆ MultiposeSolverOptions_u

Definition at line 21 of file fwd.h.

◆ MultiposeSolverOptions_w

Definition at line 22 of file fwd.h.

◆ NormalArray

Definition at line 396 of file types.h.

◆ NormalData

Definition at line 103 of file fwd.h.

◆ NormalData_const_p

Definition at line 109 of file fwd.h.

◆ NormalData_const_u

Definition at line 110 of file fwd.h.

◆ NormalData_const_w

Definition at line 111 of file fwd.h.

◆ NormalData_p

Definition at line 106 of file fwd.h.

◆ NormalData_u

Definition at line 107 of file fwd.h.

◆ NormalData_w

Definition at line 108 of file fwd.h.

◆ NormalDatad

Definition at line 104 of file fwd.h.

◆ NormalDatad_const_p

Definition at line 116 of file fwd.h.

◆ NormalDatad_const_u

Definition at line 117 of file fwd.h.

◆ NormalDatad_const_w

Definition at line 118 of file fwd.h.

◆ NormalDatad_p

Definition at line 113 of file fwd.h.

◆ NormalDatad_u

Definition at line 114 of file fwd.h.

◆ NormalDatad_w

Definition at line 115 of file fwd.h.

◆ NormalErrorFunction

◆ NormalErrorFunction_const_p

Definition at line 581 of file fwd.h.

◆ NormalErrorFunction_const_u

Definition at line 582 of file fwd.h.

◆ NormalErrorFunction_const_w

Definition at line 583 of file fwd.h.

◆ NormalErrorFunction_p

Definition at line 578 of file fwd.h.

◆ NormalErrorFunction_u

Definition at line 579 of file fwd.h.

◆ NormalErrorFunction_w

Definition at line 580 of file fwd.h.

◆ NormalErrorFunctiond

◆ NormalErrorFunctiond_const_p

Definition at line 588 of file fwd.h.

◆ NormalErrorFunctiond_const_u

Definition at line 589 of file fwd.h.

◆ NormalErrorFunctiond_const_w

◆ NormalErrorFunctiond_p

Definition at line 585 of file fwd.h.

◆ NormalErrorFunctiond_u

Definition at line 586 of file fwd.h.

◆ NormalErrorFunctiond_w

Definition at line 587 of file fwd.h.

◆ optional_ref

template<typename T >
using momentum::optional_ref = typedef std::optional<std::reference_wrapper<T> >

An optional of a reference.

Because optional<T&> is invalid, we need to use reference_wrapper to make the reference of T as an optional.

Definition at line 39 of file constraint_error_function.h.

◆ OrientationConstraint

◆ OrientationConstraint_const_p

Definition at line 45 of file fwd.h.

◆ OrientationConstraint_const_u

Definition at line 46 of file fwd.h.

◆ OrientationConstraint_const_w

◆ OrientationConstraint_p

Definition at line 42 of file fwd.h.

◆ OrientationConstraint_u

Definition at line 43 of file fwd.h.

◆ OrientationConstraint_w

Definition at line 44 of file fwd.h.

◆ OrientationConstraintd

◆ OrientationConstraintd_const_p

◆ OrientationConstraintd_const_u

◆ OrientationConstraintd_const_w

◆ OrientationConstraintd_p

Definition at line 49 of file fwd.h.

◆ OrientationConstraintd_u

Definition at line 50 of file fwd.h.

◆ OrientationConstraintd_w

Definition at line 51 of file fwd.h.

◆ OrientationConstraintState

◆ OrientationConstraintState_const_p

◆ OrientationConstraintState_const_u

◆ OrientationConstraintState_const_w

◆ OrientationConstraintState_p

Definition at line 61 of file fwd.h.

◆ OrientationConstraintState_u

Definition at line 62 of file fwd.h.

◆ OrientationConstraintState_w

◆ OrientationConstraintStated

◆ OrientationConstraintStated_const_p

◆ OrientationConstraintStated_const_u

◆ OrientationConstraintStated_const_w

◆ OrientationConstraintStated_p

◆ OrientationConstraintStated_u

◆ OrientationConstraintStated_w

◆ OrientationData

◆ OrientationData_const_p

Definition at line 128 of file fwd.h.

◆ OrientationData_const_u

Definition at line 129 of file fwd.h.

◆ OrientationData_const_w

Definition at line 130 of file fwd.h.

◆ OrientationData_p

Definition at line 125 of file fwd.h.

◆ OrientationData_u

Definition at line 126 of file fwd.h.

◆ OrientationData_w

Definition at line 127 of file fwd.h.

◆ OrientationDatad

◆ OrientationDatad_const_p

Definition at line 135 of file fwd.h.

◆ OrientationDatad_const_u

Definition at line 136 of file fwd.h.

◆ OrientationDatad_const_w

Definition at line 137 of file fwd.h.

◆ OrientationDatad_p

Definition at line 132 of file fwd.h.

◆ OrientationDatad_u

Definition at line 133 of file fwd.h.

◆ OrientationDatad_w

Definition at line 134 of file fwd.h.

◆ OrientationErrorFunction

◆ OrientationErrorFunction_const_p

◆ OrientationErrorFunction_const_u

◆ OrientationErrorFunction_const_w

◆ OrientationErrorFunction_p

Definition at line 597 of file fwd.h.

◆ OrientationErrorFunction_u

Definition at line 598 of file fwd.h.

◆ OrientationErrorFunction_w

Definition at line 599 of file fwd.h.

◆ OrientationErrorFunctiond

◆ OrientationErrorFunctiond_const_p

◆ OrientationErrorFunctiond_const_u

◆ OrientationErrorFunctiond_const_w

◆ OrientationErrorFunctiond_p

Definition at line 604 of file fwd.h.

◆ OrientationErrorFunctiond_u

Definition at line 605 of file fwd.h.

◆ OrientationErrorFunctiond_w

◆ Packet

template<typename T >
using momentum::Packet = typedef drjit::Packet<T, kSimdPacketSize>

Definition at line 39 of file simd.h.

◆ ParameterLimits

Definition at line 124 of file parameter_limits.h.

◆ ParameterSet

Definition at line 402 of file types.h.

◆ ParameterSets

using momentum::ParameterSets = typedef std::unordered_map<std::string, ParameterSet>

Definition at line 32 of file parameter_transform.h.

◆ ParameterTransform

◆ ParameterTransform_const_p

Definition at line 175 of file fwd.h.

◆ ParameterTransform_const_u

Definition at line 176 of file fwd.h.

◆ ParameterTransform_const_w

Definition at line 177 of file fwd.h.

◆ ParameterTransform_p

Definition at line 172 of file fwd.h.

◆ ParameterTransform_u

Definition at line 173 of file fwd.h.

◆ ParameterTransform_w

Definition at line 174 of file fwd.h.

◆ ParameterTransformd

◆ ParameterTransformd_const_p

Definition at line 182 of file fwd.h.

◆ ParameterTransformd_const_u

Definition at line 183 of file fwd.h.

◆ ParameterTransformd_const_w

Definition at line 184 of file fwd.h.

◆ ParameterTransformd_p

Definition at line 179 of file fwd.h.

◆ ParameterTransformd_u

Definition at line 180 of file fwd.h.

◆ ParameterTransformd_w

Definition at line 181 of file fwd.h.

◆ Plane

template<typename Scalar , int Dim>
using momentum::Plane = typedef Eigen::Hyperplane<Scalar, Dim>

Definition at line 53 of file types.h.

◆ PlaneData

Definition at line 165 of file fwd.h.

◆ PlaneData_const_p

Definition at line 171 of file fwd.h.

◆ PlaneData_const_u

Definition at line 172 of file fwd.h.

◆ PlaneData_const_w

Definition at line 173 of file fwd.h.

◆ PlaneData_p

Definition at line 168 of file fwd.h.

◆ PlaneData_u

Definition at line 169 of file fwd.h.

◆ PlaneData_w

Definition at line 170 of file fwd.h.

◆ PlaneDatad

Definition at line 166 of file fwd.h.

◆ PlaneDatad_const_p

Definition at line 178 of file fwd.h.

◆ PlaneDatad_const_u

Definition at line 179 of file fwd.h.

◆ PlaneDatad_const_w

Definition at line 180 of file fwd.h.

◆ PlaneDatad_p

Definition at line 175 of file fwd.h.

◆ PlaneDatad_u

Definition at line 176 of file fwd.h.

◆ PlaneDatad_w

Definition at line 177 of file fwd.h.

◆ PlaneErrorFunction

◆ PlaneErrorFunction_const_p

Definition at line 619 of file fwd.h.

◆ PlaneErrorFunction_const_u

Definition at line 620 of file fwd.h.

◆ PlaneErrorFunction_const_w

Definition at line 621 of file fwd.h.

◆ PlaneErrorFunction_p

Definition at line 616 of file fwd.h.

◆ PlaneErrorFunction_u

Definition at line 617 of file fwd.h.

◆ PlaneErrorFunction_w

Definition at line 618 of file fwd.h.

◆ PlaneErrorFunctiond

◆ PlaneErrorFunctiond_const_p

Definition at line 626 of file fwd.h.

◆ PlaneErrorFunctiond_const_u

Definition at line 627 of file fwd.h.

◆ PlaneErrorFunctiond_const_w

Definition at line 628 of file fwd.h.

◆ PlaneErrorFunctiond_p

Definition at line 623 of file fwd.h.

◆ PlaneErrorFunctiond_u

Definition at line 624 of file fwd.h.

◆ PlaneErrorFunctiond_w

Definition at line 625 of file fwd.h.

◆ PointTriangleVertexConstraint

◆ PointTriangleVertexConstraint_const_p

◆ PointTriangleVertexConstraint_const_u

◆ PointTriangleVertexConstraint_const_w

◆ PointTriangleVertexConstraint_p

◆ PointTriangleVertexConstraint_u

◆ PointTriangleVertexConstraint_w

◆ PointTriangleVertexConstraintd

◆ PointTriangleVertexConstraintd_const_p

◆ PointTriangleVertexConstraintd_const_u

◆ PointTriangleVertexConstraintd_const_w

◆ PointTriangleVertexConstraintd_p

◆ PointTriangleVertexConstraintd_u

◆ PointTriangleVertexConstraintd_w

◆ PointTriangleVertexErrorFunction

◆ PointTriangleVertexErrorFunction_const_p

◆ PointTriangleVertexErrorFunction_const_u

◆ PointTriangleVertexErrorFunction_const_w

◆ PointTriangleVertexErrorFunction_p

◆ PointTriangleVertexErrorFunction_u

◆ PointTriangleVertexErrorFunction_w

◆ PointTriangleVertexErrorFunctiond

◆ PointTriangleVertexErrorFunctiond_const_p

◆ PointTriangleVertexErrorFunctiond_const_u

◆ PointTriangleVertexErrorFunctiond_const_w

◆ PointTriangleVertexErrorFunctiond_p

◆ PointTriangleVertexErrorFunctiond_u

◆ PointTriangleVertexErrorFunctiond_w

◆ PoseConstraints

using momentum::PoseConstraints = typedef std::unordered_map<std::string, PoseConstraint>

Definition at line 33 of file parameter_transform.h.

◆ PosePriorErrorFunction

◆ PosePriorErrorFunction_const_p

◆ PosePriorErrorFunction_const_u

◆ PosePriorErrorFunction_const_w

◆ PosePriorErrorFunction_p

Definition at line 660 of file fwd.h.

◆ PosePriorErrorFunction_u

Definition at line 661 of file fwd.h.

◆ PosePriorErrorFunction_w

Definition at line 662 of file fwd.h.

◆ PosePriorErrorFunctiond

◆ PosePriorErrorFunctiond_const_p

◆ PosePriorErrorFunctiond_const_u

◆ PosePriorErrorFunctiond_const_w

◆ PosePriorErrorFunctiond_p

Definition at line 667 of file fwd.h.

◆ PosePriorErrorFunctiond_u

Definition at line 668 of file fwd.h.

◆ PosePriorErrorFunctiond_w

Definition at line 669 of file fwd.h.

◆ PoseShape_const_p

Definition at line 50 of file fwd.h.

◆ PoseShape_const_u

Definition at line 51 of file fwd.h.

◆ PoseShape_const_w

Definition at line 52 of file fwd.h.

◆ PoseShape_p

Definition at line 47 of file fwd.h.

◆ PoseShape_u

Definition at line 48 of file fwd.h.

◆ PoseShape_w

Definition at line 49 of file fwd.h.

◆ PoseTransformSolver

◆ PoseTransformSolver_const_p

Definition at line 682 of file fwd.h.

◆ PoseTransformSolver_const_u

Definition at line 683 of file fwd.h.

◆ PoseTransformSolver_const_w

Definition at line 684 of file fwd.h.

◆ PoseTransformSolver_p

Definition at line 679 of file fwd.h.

◆ PoseTransformSolver_u

Definition at line 680 of file fwd.h.

◆ PoseTransformSolver_w

Definition at line 681 of file fwd.h.

◆ PoseTransformSolverd

◆ PoseTransformSolverd_const_p

Definition at line 689 of file fwd.h.

◆ PoseTransformSolverd_const_u

Definition at line 690 of file fwd.h.

◆ PoseTransformSolverd_const_w

◆ PoseTransformSolverd_p

Definition at line 686 of file fwd.h.

◆ PoseTransformSolverd_u

Definition at line 687 of file fwd.h.

◆ PoseTransformSolverd_w

Definition at line 688 of file fwd.h.

◆ PositionConstraint

◆ PositionConstraint_const_p

Definition at line 83 of file fwd.h.

◆ PositionConstraint_const_u

Definition at line 84 of file fwd.h.

◆ PositionConstraint_const_w

Definition at line 85 of file fwd.h.

◆ PositionConstraint_p

Definition at line 80 of file fwd.h.

◆ PositionConstraint_u

Definition at line 81 of file fwd.h.

◆ PositionConstraint_w

Definition at line 82 of file fwd.h.

◆ PositionConstraintd

◆ PositionConstraintd_const_p

Definition at line 90 of file fwd.h.

◆ PositionConstraintd_const_u

Definition at line 91 of file fwd.h.

◆ PositionConstraintd_const_w

Definition at line 92 of file fwd.h.

◆ PositionConstraintd_p

Definition at line 87 of file fwd.h.

◆ PositionConstraintd_u

Definition at line 88 of file fwd.h.

◆ PositionConstraintd_w

Definition at line 89 of file fwd.h.

◆ PositionConstraintState

◆ PositionConstraintState_const_p

◆ PositionConstraintState_const_u

◆ PositionConstraintState_const_w

◆ PositionConstraintState_p

Definition at line 99 of file fwd.h.

◆ PositionConstraintState_u

Definition at line 100 of file fwd.h.

◆ PositionConstraintState_w

Definition at line 101 of file fwd.h.

◆ PositionConstraintStated

◆ PositionConstraintStated_const_p

◆ PositionConstraintStated_const_u

◆ PositionConstraintStated_const_w

◆ PositionConstraintStated_p

Definition at line 106 of file fwd.h.

◆ PositionConstraintStated_u

Definition at line 107 of file fwd.h.

◆ PositionConstraintStated_w

Definition at line 108 of file fwd.h.

◆ PositionData

◆ PositionData_const_p

Definition at line 190 of file fwd.h.

◆ PositionData_const_u

Definition at line 191 of file fwd.h.

◆ PositionData_const_w

Definition at line 192 of file fwd.h.

◆ PositionData_p

Definition at line 187 of file fwd.h.

◆ PositionData_u

Definition at line 188 of file fwd.h.

◆ PositionData_w

Definition at line 189 of file fwd.h.

◆ PositionDatad

◆ PositionDatad_const_p

Definition at line 197 of file fwd.h.

◆ PositionDatad_const_u

Definition at line 198 of file fwd.h.

◆ PositionDatad_const_w

Definition at line 199 of file fwd.h.

◆ PositionDatad_p

Definition at line 194 of file fwd.h.

◆ PositionDatad_u

Definition at line 195 of file fwd.h.

◆ PositionDatad_w

Definition at line 196 of file fwd.h.

◆ PositionErrorFunction

◆ PositionErrorFunction_const_p

Definition at line 701 of file fwd.h.

◆ PositionErrorFunction_const_u

Definition at line 702 of file fwd.h.

◆ PositionErrorFunction_const_w

◆ PositionErrorFunction_p

Definition at line 698 of file fwd.h.

◆ PositionErrorFunction_u

Definition at line 699 of file fwd.h.

◆ PositionErrorFunction_w

Definition at line 700 of file fwd.h.

◆ PositionErrorFunctiond

◆ PositionErrorFunctiond_const_p

◆ PositionErrorFunctiond_const_u

◆ PositionErrorFunctiond_const_w

◆ PositionErrorFunctiond_p

Definition at line 705 of file fwd.h.

◆ PositionErrorFunctiond_u

Definition at line 706 of file fwd.h.

◆ PositionErrorFunctiond_w

Definition at line 707 of file fwd.h.

◆ ProgressBar_const_p

Definition at line 23 of file fwd.h.

◆ ProgressBar_const_u

Definition at line 24 of file fwd.h.

◆ ProgressBar_const_w

Definition at line 25 of file fwd.h.

◆ ProgressBar_p

Definition at line 20 of file fwd.h.

◆ ProgressBar_u

Definition at line 21 of file fwd.h.

◆ ProgressBar_w

Definition at line 22 of file fwd.h.

◆ ProjectionErrorFunction

◆ ProjectionErrorFunction_const_p

◆ ProjectionErrorFunction_const_u

◆ ProjectionErrorFunction_const_w

◆ ProjectionErrorFunction_p

Definition at line 717 of file fwd.h.

◆ ProjectionErrorFunction_u

Definition at line 718 of file fwd.h.

◆ ProjectionErrorFunction_w

Definition at line 719 of file fwd.h.

◆ ProjectionErrorFunctiond

◆ ProjectionErrorFunctiond_const_p

◆ ProjectionErrorFunctiond_const_u

◆ ProjectionErrorFunctiond_const_w

◆ ProjectionErrorFunctiond_p

Definition at line 724 of file fwd.h.

◆ ProjectionErrorFunctiond_u

Definition at line 725 of file fwd.h.

◆ ProjectionErrorFunctiond_w

Definition at line 726 of file fwd.h.

◆ Quaternion

template<typename T >
using momentum::Quaternion = typedef Eigen::Quaternion<T>

Definition at line 371 of file types.h.

◆ Quaterniond

◆ Quaternionf

Definition at line 372 of file types.h.

◆ Ref

template<class T >
using momentum::Ref = typedef Eigen::Ref<T>

Definition at line 47 of file types.h.

◆ RowMatrix

template<typename T , int N, int M = N>
using momentum::RowMatrix = typedef Eigen::Matrix<T, N, M, Eigen::RowMajor>

Definition at line 173 of file types.h.

◆ RowMatrixX

Definition at line 175 of file types.h.

◆ RowVector

template<typename T , int Dim>
using momentum::RowVector = typedef Eigen::Matrix<T, 1, Dim>

Definition at line 291 of file types.h.

◆ RowVector0

Definition at line 303 of file types.h.

◆ RowVector0b

Definition at line 333 of file types.h.

◆ RowVector0d

◆ RowVector0f

Definition at line 317 of file types.h.

◆ RowVector0i

Definition at line 357 of file types.h.

◆ RowVector0s

Definition at line 341 of file types.h.

◆ RowVector0u

Definition at line 349 of file types.h.

◆ RowVector1

Definition at line 305 of file types.h.

◆ RowVector1b

Definition at line 334 of file types.h.

◆ RowVector1d

◆ RowVector1f

Definition at line 318 of file types.h.

◆ RowVector1i

Definition at line 358 of file types.h.

◆ RowVector1s

Definition at line 342 of file types.h.

◆ RowVector1u

Definition at line 350 of file types.h.

◆ RowVector2

Definition at line 307 of file types.h.

◆ RowVector2b

Definition at line 335 of file types.h.

◆ RowVector2d

◆ RowVector2f

Definition at line 319 of file types.h.

◆ RowVector2i

Definition at line 359 of file types.h.

◆ RowVector2s

Definition at line 343 of file types.h.

◆ RowVector2u

Definition at line 351 of file types.h.

◆ RowVector3

Definition at line 309 of file types.h.

◆ RowVector3b

Definition at line 336 of file types.h.

◆ RowVector3d

◆ RowVector3f

Definition at line 320 of file types.h.

◆ RowVector3i

Definition at line 360 of file types.h.

◆ RowVector3s

Definition at line 344 of file types.h.

◆ RowVector3u

Definition at line 352 of file types.h.

◆ RowVector4

Definition at line 311 of file types.h.

◆ RowVector4b

Definition at line 337 of file types.h.

◆ RowVector4d

◆ RowVector4f

Definition at line 321 of file types.h.

◆ RowVector4i

Definition at line 361 of file types.h.

◆ RowVector4s

Definition at line 345 of file types.h.

◆ RowVector4u

Definition at line 353 of file types.h.

◆ RowVector5

Definition at line 313 of file types.h.

◆ RowVector5b

Definition at line 338 of file types.h.

◆ RowVector5d

◆ RowVector5f

Definition at line 322 of file types.h.

◆ RowVector5i

Definition at line 362 of file types.h.

◆ RowVector5s

Definition at line 346 of file types.h.

◆ RowVector5u

Definition at line 354 of file types.h.

◆ RowVector6

Definition at line 315 of file types.h.

◆ RowVector6b

Definition at line 339 of file types.h.

◆ RowVector6d

◆ RowVector6f

Definition at line 323 of file types.h.

◆ RowVector6i

Definition at line 363 of file types.h.

◆ RowVector6s

Definition at line 347 of file types.h.

◆ RowVector6u

Definition at line 355 of file types.h.

◆ RowVectorX

Definition at line 293 of file types.h.

◆ RowVectorXb

Definition at line 297 of file types.h.

◆ RowVectorXd

◆ RowVectorXf

Definition at line 295 of file types.h.

◆ RowVectorXi

Definition at line 300 of file types.h.

◆ RowVectorXs

Definition at line 298 of file types.h.

◆ RowVectorXu

Definition at line 299 of file types.h.

◆ SequenceErrorFunction

◆ SequenceErrorFunction_const_p

Definition at line 119 of file fwd.h.

◆ SequenceErrorFunction_const_u

Definition at line 120 of file fwd.h.

◆ SequenceErrorFunction_const_w

◆ SequenceErrorFunction_p

Definition at line 116 of file fwd.h.

◆ SequenceErrorFunction_u

Definition at line 117 of file fwd.h.

◆ SequenceErrorFunction_w

Definition at line 118 of file fwd.h.

◆ SequenceErrorFunctiond

◆ SequenceErrorFunctiond_const_p

◆ SequenceErrorFunctiond_const_u

◆ SequenceErrorFunctiond_const_w

◆ SequenceErrorFunctiond_p

Definition at line 123 of file fwd.h.

◆ SequenceErrorFunctiond_u

Definition at line 124 of file fwd.h.

◆ SequenceErrorFunctiond_w

Definition at line 125 of file fwd.h.

◆ SequenceSolver

◆ SequenceSolver_const_p

Definition at line 207 of file fwd.h.

◆ SequenceSolver_const_u

Definition at line 208 of file fwd.h.

◆ SequenceSolver_const_w

Definition at line 209 of file fwd.h.

◆ SequenceSolver_p

Definition at line 204 of file fwd.h.

◆ SequenceSolver_u

Definition at line 205 of file fwd.h.

◆ SequenceSolver_w

Definition at line 206 of file fwd.h.

◆ SequenceSolverd

◆ SequenceSolverd_const_p

Definition at line 214 of file fwd.h.

◆ SequenceSolverd_const_u

Definition at line 215 of file fwd.h.

◆ SequenceSolverd_const_w

Definition at line 216 of file fwd.h.

◆ SequenceSolverd_p

Definition at line 211 of file fwd.h.

◆ SequenceSolverd_u

Definition at line 212 of file fwd.h.

◆ SequenceSolverd_w

Definition at line 213 of file fwd.h.

◆ SequenceSolverFunction

◆ SequenceSolverFunction_const_p

◆ SequenceSolverFunction_const_u

◆ SequenceSolverFunction_const_w

◆ SequenceSolverFunction_p

Definition at line 223 of file fwd.h.

◆ SequenceSolverFunction_u

Definition at line 224 of file fwd.h.

◆ SequenceSolverFunction_w

Definition at line 225 of file fwd.h.

◆ SequenceSolverFunctiond

◆ SequenceSolverFunctiond_const_p

◆ SequenceSolverFunctiond_const_u

◆ SequenceSolverFunctiond_const_w

◆ SequenceSolverFunctiond_p

Definition at line 230 of file fwd.h.

◆ SequenceSolverFunctiond_u

Definition at line 231 of file fwd.h.

◆ SequenceSolverFunctiond_w

Definition at line 232 of file fwd.h.

◆ SequenceSolverOptions_const_p

Definition at line 32 of file fwd.h.

◆ SequenceSolverOptions_const_u

Definition at line 33 of file fwd.h.

◆ SequenceSolverOptions_const_w

◆ SequenceSolverOptions_p

Definition at line 29 of file fwd.h.

◆ SequenceSolverOptions_u

Definition at line 30 of file fwd.h.

◆ SequenceSolverOptions_w

Definition at line 31 of file fwd.h.

◆ SimdCollisionErrorFunction

◆ SimdCollisionErrorFunction_const_p

◆ SimdCollisionErrorFunction_const_u

◆ SimdCollisionErrorFunction_const_w

◆ SimdCollisionErrorFunction_p

Definition at line 736 of file fwd.h.

◆ SimdCollisionErrorFunction_u

Definition at line 737 of file fwd.h.

◆ SimdCollisionErrorFunction_w

◆ SimdCollisionErrorFunctiond

◆ SimdCollisionErrorFunctiond_const_p

◆ SimdCollisionErrorFunctiond_const_u

◆ SimdCollisionErrorFunctiond_const_w

◆ SimdCollisionErrorFunctiond_p

◆ SimdCollisionErrorFunctiond_u

◆ SimdCollisionErrorFunctiond_w

◆ SimdGeneralizedLoss

◆ SimdGeneralizedLoss_const_p

Definition at line 121 of file fwd.h.

◆ SimdGeneralizedLoss_const_u

Definition at line 122 of file fwd.h.

◆ SimdGeneralizedLoss_const_w

Definition at line 123 of file fwd.h.

◆ SimdGeneralizedLoss_p

Definition at line 118 of file fwd.h.

◆ SimdGeneralizedLoss_u

Definition at line 119 of file fwd.h.

◆ SimdGeneralizedLoss_w

Definition at line 120 of file fwd.h.

◆ SimdGeneralizedLossd

◆ SimdGeneralizedLossd_const_p

Definition at line 128 of file fwd.h.

◆ SimdGeneralizedLossd_const_u

Definition at line 129 of file fwd.h.

◆ SimdGeneralizedLossd_const_w

◆ SimdGeneralizedLossd_p

Definition at line 125 of file fwd.h.

◆ SimdGeneralizedLossd_u

Definition at line 126 of file fwd.h.

◆ SimdGeneralizedLossd_w

Definition at line 127 of file fwd.h.

◆ SimdNormalConstraints_const_p

Definition at line 41 of file fwd.h.

◆ SimdNormalConstraints_const_u

Definition at line 42 of file fwd.h.

◆ SimdNormalConstraints_const_w

◆ SimdNormalConstraints_p

Definition at line 38 of file fwd.h.

◆ SimdNormalConstraints_u

Definition at line 39 of file fwd.h.

◆ SimdNormalConstraints_w

Definition at line 40 of file fwd.h.

◆ SimdNormalErrorFunction_const_p

◆ SimdNormalErrorFunction_const_u

◆ SimdNormalErrorFunction_const_w

◆ SimdNormalErrorFunction_p

Definition at line 285 of file fwd.h.

◆ SimdNormalErrorFunction_u

Definition at line 286 of file fwd.h.

◆ SimdNormalErrorFunction_w

Definition at line 287 of file fwd.h.

◆ SimdNormalErrorFunctionAVX_const_p

◆ SimdNormalErrorFunctionAVX_const_u

◆ SimdNormalErrorFunctionAVX_const_w

◆ SimdNormalErrorFunctionAVX_p

Definition at line 312 of file fwd.h.

◆ SimdNormalErrorFunctionAVX_u

Definition at line 313 of file fwd.h.

◆ SimdNormalErrorFunctionAVX_w

◆ SimdPlaneConstraints_const_p

Definition at line 50 of file fwd.h.

◆ SimdPlaneConstraints_const_u

Definition at line 51 of file fwd.h.

◆ SimdPlaneConstraints_const_w

Definition at line 52 of file fwd.h.

◆ SimdPlaneConstraints_p

Definition at line 47 of file fwd.h.

◆ SimdPlaneConstraints_u

Definition at line 48 of file fwd.h.

◆ SimdPlaneConstraints_w

Definition at line 49 of file fwd.h.

◆ SimdPlaneErrorFunction_const_p

◆ SimdPlaneErrorFunction_const_u

◆ SimdPlaneErrorFunction_const_w

◆ SimdPlaneErrorFunction_p

Definition at line 294 of file fwd.h.

◆ SimdPlaneErrorFunction_u

Definition at line 295 of file fwd.h.

◆ SimdPlaneErrorFunction_w

Definition at line 296 of file fwd.h.

◆ SimdPlaneErrorFunctionAVX_const_p

◆ SimdPlaneErrorFunctionAVX_const_u

◆ SimdPlaneErrorFunctionAVX_const_w

◆ SimdPlaneErrorFunctionAVX_p

Definition at line 321 of file fwd.h.

◆ SimdPlaneErrorFunctionAVX_u

Definition at line 322 of file fwd.h.

◆ SimdPlaneErrorFunctionAVX_w

◆ SimdPositionConstraints_const_p

◆ SimdPositionConstraints_const_u

◆ SimdPositionConstraints_const_w

◆ SimdPositionConstraints_p

Definition at line 56 of file fwd.h.

◆ SimdPositionConstraints_u

Definition at line 57 of file fwd.h.

◆ SimdPositionConstraints_w

Definition at line 58 of file fwd.h.

◆ SimdPositionErrorFunction_const_p

◆ SimdPositionErrorFunction_const_u

◆ SimdPositionErrorFunction_const_w

◆ SimdPositionErrorFunction_p

Definition at line 303 of file fwd.h.

◆ SimdPositionErrorFunction_u

Definition at line 304 of file fwd.h.

◆ SimdPositionErrorFunction_w

◆ SimdPositionErrorFunctionAVX_const_p

◆ SimdPositionErrorFunctionAVX_const_u

◆ SimdPositionErrorFunctionAVX_const_w

◆ SimdPositionErrorFunctionAVX_p

◆ SimdPositionErrorFunctionAVX_u

◆ SimdPositionErrorFunctionAVX_w

◆ Skeleton

Definition at line 188 of file fwd.h.

◆ Skeleton_const_p

Definition at line 194 of file fwd.h.

◆ Skeleton_const_u

Definition at line 195 of file fwd.h.

◆ Skeleton_const_w

Definition at line 196 of file fwd.h.

◆ Skeleton_p

Definition at line 191 of file fwd.h.

◆ Skeleton_u

Definition at line 192 of file fwd.h.

◆ Skeleton_w

Definition at line 193 of file fwd.h.

◆ Skeletond

Definition at line 189 of file fwd.h.

◆ Skeletond_const_p

Definition at line 201 of file fwd.h.

◆ Skeletond_const_u

Definition at line 202 of file fwd.h.

◆ Skeletond_const_w

Definition at line 203 of file fwd.h.

◆ Skeletond_p

Definition at line 198 of file fwd.h.

◆ Skeletond_u

Definition at line 199 of file fwd.h.

◆ Skeletond_w

Definition at line 200 of file fwd.h.

◆ SkeletonErrorFunction

◆ SkeletonErrorFunction_const_p

Definition at line 758 of file fwd.h.

◆ SkeletonErrorFunction_const_u

Definition at line 759 of file fwd.h.

◆ SkeletonErrorFunction_const_w

◆ SkeletonErrorFunction_p

Definition at line 755 of file fwd.h.

◆ SkeletonErrorFunction_u

Definition at line 756 of file fwd.h.

◆ SkeletonErrorFunction_w

Definition at line 757 of file fwd.h.

◆ SkeletonErrorFunctiond

◆ SkeletonErrorFunctiond_const_p

◆ SkeletonErrorFunctiond_const_u

◆ SkeletonErrorFunctiond_const_w

◆ SkeletonErrorFunctiond_p

Definition at line 762 of file fwd.h.

◆ SkeletonErrorFunctiond_u

Definition at line 763 of file fwd.h.

◆ SkeletonErrorFunctiond_w

Definition at line 764 of file fwd.h.

◆ SkeletonSolverFunction

◆ SkeletonSolverFunction_const_p

◆ SkeletonSolverFunction_const_u

◆ SkeletonSolverFunction_const_w

◆ SkeletonSolverFunction_p

Definition at line 774 of file fwd.h.

◆ SkeletonSolverFunction_u

Definition at line 775 of file fwd.h.

◆ SkeletonSolverFunction_w

Definition at line 776 of file fwd.h.

◆ SkeletonSolverFunctiond

◆ SkeletonSolverFunctiond_const_p

◆ SkeletonSolverFunctiond_const_u

◆ SkeletonSolverFunctiond_const_w

◆ SkeletonSolverFunctiond_p

Definition at line 781 of file fwd.h.

◆ SkeletonSolverFunctiond_u

Definition at line 782 of file fwd.h.

◆ SkeletonSolverFunctiond_w

Definition at line 783 of file fwd.h.

◆ SkeletonState

◆ SkeletonState_const_p

Definition at line 213 of file fwd.h.

◆ SkeletonState_const_u

Definition at line 214 of file fwd.h.

◆ SkeletonState_const_w

Definition at line 215 of file fwd.h.

◆ SkeletonState_p

Definition at line 210 of file fwd.h.

◆ SkeletonState_u

Definition at line 211 of file fwd.h.

◆ SkeletonState_w

Definition at line 212 of file fwd.h.

◆ SkeletonStated

◆ SkeletonStated_const_p

Definition at line 220 of file fwd.h.

◆ SkeletonStated_const_u

Definition at line 221 of file fwd.h.

◆ SkeletonStated_const_w

Definition at line 222 of file fwd.h.

◆ SkeletonStated_p

Definition at line 217 of file fwd.h.

◆ SkeletonStated_u

Definition at line 218 of file fwd.h.

◆ SkeletonStated_w

Definition at line 219 of file fwd.h.

◆ SkinnedLocator_const_p

Definition at line 68 of file fwd.h.

◆ SkinnedLocator_const_u

Definition at line 69 of file fwd.h.

◆ SkinnedLocator_const_w

Definition at line 70 of file fwd.h.

◆ SkinnedLocator_p

Definition at line 65 of file fwd.h.

◆ SkinnedLocator_u

Definition at line 66 of file fwd.h.

◆ SkinnedLocator_w

Definition at line 67 of file fwd.h.

◆ SkinnedLocatorConstraint

◆ SkinnedLocatorConstraint_const_p

◆ SkinnedLocatorConstraint_const_u

◆ SkinnedLocatorConstraint_const_w

◆ SkinnedLocatorConstraint_p

Definition at line 206 of file fwd.h.

◆ SkinnedLocatorConstraint_u

Definition at line 207 of file fwd.h.

◆ SkinnedLocatorConstraint_w

Definition at line 208 of file fwd.h.

◆ SkinnedLocatorConstraintd

◆ SkinnedLocatorConstraintd_const_p

◆ SkinnedLocatorConstraintd_const_u

◆ SkinnedLocatorConstraintd_const_w

◆ SkinnedLocatorConstraintd_p

Definition at line 213 of file fwd.h.

◆ SkinnedLocatorConstraintd_u

Definition at line 214 of file fwd.h.

◆ SkinnedLocatorConstraintd_w

◆ SkinnedLocatorErrorFunction

◆ SkinnedLocatorErrorFunction_const_p

◆ SkinnedLocatorErrorFunction_const_u

◆ SkinnedLocatorErrorFunction_const_w

◆ SkinnedLocatorErrorFunction_p

◆ SkinnedLocatorErrorFunction_u

◆ SkinnedLocatorErrorFunction_w

◆ SkinnedLocatorErrorFunctiond

◆ SkinnedLocatorErrorFunctiond_const_p

◆ SkinnedLocatorErrorFunctiond_const_u

◆ SkinnedLocatorErrorFunctiond_const_w

◆ SkinnedLocatorErrorFunctiond_p

◆ SkinnedLocatorErrorFunctiond_u

◆ SkinnedLocatorErrorFunctiond_w

◆ SkinnedLocatorList

A collection of locators attached to a skeleton.

Definition at line 78 of file skinned_locator.h.

◆ SkinnedLocatorTriangleConstraint

◆ SkinnedLocatorTriangleConstraint_const_p

◆ SkinnedLocatorTriangleConstraint_const_u

◆ SkinnedLocatorTriangleConstraint_const_w

◆ SkinnedLocatorTriangleConstraint_p

◆ SkinnedLocatorTriangleConstraint_u

◆ SkinnedLocatorTriangleConstraint_w

◆ SkinnedLocatorTriangleConstraintd

◆ SkinnedLocatorTriangleConstraintd_const_p

◆ SkinnedLocatorTriangleConstraintd_const_u

◆ SkinnedLocatorTriangleConstraintd_const_w

◆ SkinnedLocatorTriangleConstraintd_p

◆ SkinnedLocatorTriangleConstraintd_u

◆ SkinnedLocatorTriangleConstraintd_w

◆ SkinnedLocatorTriangleErrorFunction

◆ SkinnedLocatorTriangleErrorFunction_const_p

◆ SkinnedLocatorTriangleErrorFunction_const_u

◆ SkinnedLocatorTriangleErrorFunction_const_w

◆ SkinnedLocatorTriangleErrorFunction_p

◆ SkinnedLocatorTriangleErrorFunction_u

◆ SkinnedLocatorTriangleErrorFunction_w

◆ SkinnedLocatorTriangleErrorFunctiond

◆ SkinnedLocatorTriangleErrorFunctiond_const_p

◆ SkinnedLocatorTriangleErrorFunctiond_const_u

◆ SkinnedLocatorTriangleErrorFunctiond_const_w

◆ SkinnedLocatorTriangleErrorFunctiond_p

◆ SkinnedLocatorTriangleErrorFunctiond_u

◆ SkinnedLocatorTriangleErrorFunctiond_w

◆ SkinWeights_const_p

Definition at line 59 of file fwd.h.

◆ SkinWeights_const_u

Definition at line 60 of file fwd.h.

◆ SkinWeights_const_w

Definition at line 61 of file fwd.h.

◆ SkinWeights_p

Definition at line 56 of file fwd.h.

◆ SkinWeights_u

Definition at line 57 of file fwd.h.

◆ SkinWeights_w

Definition at line 58 of file fwd.h.

◆ Solver

Definition at line 50 of file fwd.h.

◆ Solver_const_p

Definition at line 56 of file fwd.h.

◆ Solver_const_u

Definition at line 57 of file fwd.h.

◆ Solver_const_w

Definition at line 58 of file fwd.h.

◆ Solver_p

using momentum::Solver_p = typedef ::std::shared_ptr<Solver>

Definition at line 53 of file fwd.h.

◆ Solver_u

using momentum::Solver_u = typedef ::std::unique_ptr<Solver>

Definition at line 54 of file fwd.h.

◆ Solver_w

using momentum::Solver_w = typedef ::std::weak_ptr<Solver>

Definition at line 55 of file fwd.h.

◆ Solverd

Definition at line 51 of file fwd.h.

◆ Solverd_const_p

Definition at line 63 of file fwd.h.

◆ Solverd_const_u

Definition at line 64 of file fwd.h.

◆ Solverd_const_w

Definition at line 65 of file fwd.h.

◆ Solverd_p

using momentum::Solverd_p = typedef ::std::shared_ptr<Solverd>

Definition at line 60 of file fwd.h.

◆ Solverd_u

using momentum::Solverd_u = typedef ::std::unique_ptr<Solverd>

Definition at line 61 of file fwd.h.

◆ Solverd_w

Definition at line 62 of file fwd.h.

◆ SolverFunction

◆ SolverFunction_const_p

Definition at line 75 of file fwd.h.

◆ SolverFunction_const_u

Definition at line 76 of file fwd.h.

◆ SolverFunction_const_w

Definition at line 77 of file fwd.h.

◆ SolverFunction_p

Definition at line 72 of file fwd.h.

◆ SolverFunction_u

Definition at line 73 of file fwd.h.

◆ SolverFunction_w

Definition at line 74 of file fwd.h.

◆ SolverFunctiond

◆ SolverFunctiond_const_p

Definition at line 82 of file fwd.h.

◆ SolverFunctiond_const_u

Definition at line 83 of file fwd.h.

◆ SolverFunctiond_const_w

Definition at line 84 of file fwd.h.

◆ SolverFunctiond_p

Definition at line 79 of file fwd.h.

◆ SolverFunctiond_u

Definition at line 80 of file fwd.h.

◆ SolverFunctiond_w

Definition at line 81 of file fwd.h.

◆ SolverOptions_const_p

Definition at line 23 of file fwd.h.

◆ SolverOptions_const_u

Definition at line 24 of file fwd.h.

◆ SolverOptions_const_w

Definition at line 25 of file fwd.h.

◆ SolverOptions_p

Definition at line 20 of file fwd.h.

◆ SolverOptions_u

Definition at line 21 of file fwd.h.

◆ SolverOptions_w

Definition at line 22 of file fwd.h.

◆ SparseGaussNewtonSolver

◆ SparseGaussNewtonSolver_const_p

◆ SparseGaussNewtonSolver_const_u

◆ SparseGaussNewtonSolver_const_w

◆ SparseGaussNewtonSolver_p

Definition at line 110 of file fwd.h.

◆ SparseGaussNewtonSolver_u

Definition at line 111 of file fwd.h.

◆ SparseGaussNewtonSolver_w

Definition at line 112 of file fwd.h.

◆ SparseGaussNewtonSolverd

◆ SparseGaussNewtonSolverd_const_p

◆ SparseGaussNewtonSolverd_const_u

◆ SparseGaussNewtonSolverd_const_w

◆ SparseGaussNewtonSolverd_p

Definition at line 117 of file fwd.h.

◆ SparseGaussNewtonSolverd_u

Definition at line 118 of file fwd.h.

◆ SparseGaussNewtonSolverd_w

Definition at line 119 of file fwd.h.

◆ SparseGaussNewtonSolverOptions_const_p

◆ SparseGaussNewtonSolverOptions_const_u

◆ SparseGaussNewtonSolverOptions_const_w

◆ SparseGaussNewtonSolverOptions_p

◆ SparseGaussNewtonSolverOptions_u

◆ SparseGaussNewtonSolverOptions_w

◆ SparseMatrix

template<typename T >
using momentum::SparseMatrix = typedef Eigen::SparseMatrix<T>

Definition at line 178 of file types.h.

◆ SparseMatrixb

Definition at line 181 of file types.h.

◆ SparseMatrixd

◆ SparseMatrixf

◆ SparseMatrixi

Definition at line 184 of file types.h.

◆ SparseMatrixs

Definition at line 182 of file types.h.

◆ SparseMatrixu

Definition at line 183 of file types.h.

◆ SparseRowMatrix

template<typename T >
using momentum::SparseRowMatrix = typedef Eigen::SparseMatrix<T, Eigen::RowMajor>

Definition at line 187 of file types.h.

◆ SparseRowMatrixb

Definition at line 190 of file types.h.

◆ SparseRowMatrixd

◆ SparseRowMatrixf

◆ SparseRowMatrixi

Definition at line 193 of file types.h.

◆ SparseRowMatrixs

Definition at line 191 of file types.h.

◆ SparseRowMatrixu

Definition at line 192 of file types.h.

◆ StateErrorFunction

◆ StateErrorFunction_const_p

Definition at line 845 of file fwd.h.

◆ StateErrorFunction_const_u

Definition at line 846 of file fwd.h.

◆ StateErrorFunction_const_w

Definition at line 847 of file fwd.h.

◆ StateErrorFunction_p

Definition at line 842 of file fwd.h.

◆ StateErrorFunction_u

Definition at line 843 of file fwd.h.

◆ StateErrorFunction_w

Definition at line 844 of file fwd.h.

◆ StateErrorFunctiond

◆ StateErrorFunctiond_const_p

Definition at line 852 of file fwd.h.

◆ StateErrorFunctiond_const_u

Definition at line 853 of file fwd.h.

◆ StateErrorFunctiond_const_w

Definition at line 854 of file fwd.h.

◆ StateErrorFunctiond_p

Definition at line 849 of file fwd.h.

◆ StateErrorFunctiond_u

Definition at line 850 of file fwd.h.

◆ StateErrorFunctiond_w

Definition at line 851 of file fwd.h.

◆ StateSequenceErrorFunction

◆ StateSequenceErrorFunction_const_p

◆ StateSequenceErrorFunction_const_u

◆ StateSequenceErrorFunction_const_w

◆ StateSequenceErrorFunction_p

Definition at line 242 of file fwd.h.

◆ StateSequenceErrorFunction_u

Definition at line 243 of file fwd.h.

◆ StateSequenceErrorFunction_w

◆ StateSequenceErrorFunctiond

◆ StateSequenceErrorFunctiond_const_p

◆ StateSequenceErrorFunctiond_const_u

◆ StateSequenceErrorFunctiond_const_w

◆ StateSequenceErrorFunctiond_p

◆ StateSequenceErrorFunctiond_u

◆ StateSequenceErrorFunctiond_w

◆ SubsetGaussNewtonSolver

◆ SubsetGaussNewtonSolver_const_p

◆ SubsetGaussNewtonSolver_const_u

◆ SubsetGaussNewtonSolver_const_w

◆ SubsetGaussNewtonSolver_p

Definition at line 148 of file fwd.h.

◆ SubsetGaussNewtonSolver_u

Definition at line 149 of file fwd.h.

◆ SubsetGaussNewtonSolver_w

Definition at line 150 of file fwd.h.

◆ SubsetGaussNewtonSolverd

◆ SubsetGaussNewtonSolverd_const_p

◆ SubsetGaussNewtonSolverd_const_u

◆ SubsetGaussNewtonSolverd_const_w

◆ SubsetGaussNewtonSolverd_p

Definition at line 155 of file fwd.h.

◆ SubsetGaussNewtonSolverd_u

Definition at line 156 of file fwd.h.

◆ SubsetGaussNewtonSolverd_w

Definition at line 157 of file fwd.h.

◆ TaperedCapsule

◆ TaperedCapsule_const_p

Definition at line 251 of file fwd.h.

◆ TaperedCapsule_const_u

Definition at line 252 of file fwd.h.

◆ TaperedCapsule_const_w

Definition at line 253 of file fwd.h.

◆ TaperedCapsule_p

Definition at line 248 of file fwd.h.

◆ TaperedCapsule_u

Definition at line 249 of file fwd.h.

◆ TaperedCapsule_w

Definition at line 250 of file fwd.h.

◆ TaperedCapsuled

◆ TaperedCapsuled_const_p

Definition at line 258 of file fwd.h.

◆ TaperedCapsuled_const_u

Definition at line 259 of file fwd.h.

◆ TaperedCapsuled_const_w

Definition at line 260 of file fwd.h.

◆ TaperedCapsuled_p

Definition at line 255 of file fwd.h.

◆ TaperedCapsuled_u

Definition at line 256 of file fwd.h.

◆ TaperedCapsuled_w

Definition at line 257 of file fwd.h.

◆ Transform

Definition at line 58 of file fwd.h.

◆ Transform_const_p

Definition at line 64 of file fwd.h.

◆ Transform_const_u

Definition at line 65 of file fwd.h.

◆ Transform_const_w

Definition at line 66 of file fwd.h.

◆ Transform_p

Definition at line 61 of file fwd.h.

◆ Transform_u

Definition at line 62 of file fwd.h.

◆ Transform_w

Definition at line 63 of file fwd.h.

◆ TransformationList

Definition at line 391 of file types.h.

◆ TransformationListT

Definition at line 393 of file types.h.

◆ Transformd

Definition at line 59 of file fwd.h.

◆ Transformd_const_p

Definition at line 71 of file fwd.h.

◆ Transformd_const_u

Definition at line 72 of file fwd.h.

◆ Transformd_const_w

Definition at line 73 of file fwd.h.

◆ Transformd_p

Definition at line 68 of file fwd.h.

◆ Transformd_u

Definition at line 69 of file fwd.h.

◆ Transformd_w

Definition at line 70 of file fwd.h.

◆ TransformList

◆ TransformListT

Definition at line 214 of file transform.h.

◆ Translation3

template<typename T >
using momentum::Translation3 = typedef Eigen::Translation<T, 3>

Definition at line 376 of file types.h.

◆ Translation3d

◆ Translation3f

◆ TriangleArray

Definition at line 397 of file types.h.

◆ TrustRegionQR

◆ TrustRegionQR_const_p

Definition at line 864 of file fwd.h.

◆ TrustRegionQR_const_u

Definition at line 865 of file fwd.h.

◆ TrustRegionQR_const_w

Definition at line 866 of file fwd.h.

◆ TrustRegionQR_p

Definition at line 861 of file fwd.h.

◆ TrustRegionQR_u

Definition at line 862 of file fwd.h.

◆ TrustRegionQR_w

Definition at line 863 of file fwd.h.

◆ TrustRegionQRd

◆ TrustRegionQRd_const_p

Definition at line 871 of file fwd.h.

◆ TrustRegionQRd_const_u

Definition at line 872 of file fwd.h.

◆ TrustRegionQRd_const_w

Definition at line 873 of file fwd.h.

◆ TrustRegionQRd_p

Definition at line 868 of file fwd.h.

◆ TrustRegionQRd_u

Definition at line 869 of file fwd.h.

◆ TrustRegionQRd_w

Definition at line 870 of file fwd.h.

◆ UintP

Definition at line 62 of file simd.h.

◆ UnionErrorFunction

◆ UnionErrorFunction_const_p

Definition at line 374 of file fwd.h.

◆ UnionErrorFunction_const_u

Definition at line 375 of file fwd.h.

◆ UnionErrorFunction_const_w

Definition at line 376 of file fwd.h.

◆ UnionErrorFunction_p

Definition at line 371 of file fwd.h.

◆ UnionErrorFunction_u

Definition at line 372 of file fwd.h.

◆ UnionErrorFunction_w

Definition at line 373 of file fwd.h.

◆ UnionErrorFunctiond

◆ UnionErrorFunctiond_const_p

Definition at line 381 of file fwd.h.

◆ UnionErrorFunctiond_const_u

Definition at line 382 of file fwd.h.

◆ UnionErrorFunctiond_const_w

Definition at line 383 of file fwd.h.

◆ UnionErrorFunctiond_p

Definition at line 378 of file fwd.h.

◆ UnionErrorFunctiond_u

Definition at line 379 of file fwd.h.

◆ UnionErrorFunctiond_w

Definition at line 380 of file fwd.h.

◆ Vector

template<typename T , int Dim, int Options = 0>
using momentum::Vector = typedef Eigen::Matrix<T, Dim, 1, Options>

Definition at line 196 of file types.h.

◆ Vector0

Definition at line 222 of file types.h.

◆ Vector0b

Definition at line 258 of file types.h.

◆ Vector0d

Definition at line 250 of file types.h.

◆ Vector0f

Definition at line 240 of file types.h.

◆ Vector0i

Definition at line 282 of file types.h.

◆ Vector0s

Definition at line 266 of file types.h.

◆ Vector0u

Definition at line 274 of file types.h.

◆ Vector1

Definition at line 224 of file types.h.

◆ Vector1b

Definition at line 259 of file types.h.

◆ Vector1d

Definition at line 251 of file types.h.

◆ Vector1f

Definition at line 241 of file types.h.

◆ Vector1i

Definition at line 283 of file types.h.

◆ Vector1s

Definition at line 267 of file types.h.

◆ Vector1u

Definition at line 275 of file types.h.

◆ Vector2

Definition at line 226 of file types.h.

◆ Vector2b

Definition at line 260 of file types.h.

◆ Vector2d

Definition at line 252 of file types.h.

◆ Vector2dP

Definition at line 57 of file simd.h.

◆ Vector2f

Definition at line 242 of file types.h.

◆ Vector2fP

Definition at line 54 of file simd.h.

◆ Vector2i

Definition at line 284 of file types.h.

◆ Vector2iP

using momentum::Vector2iP = typedef drjit::Array<IntP, 2>

Integer and byte vector types.

Definition at line 65 of file simd.h.

◆ Vector2P

Definition at line 49 of file simd.h.

◆ Vector2s

Definition at line 268 of file types.h.

◆ Vector2u

Definition at line 276 of file types.h.

◆ Vector3

Definition at line 228 of file types.h.

◆ Vector3b

Definition at line 261 of file types.h.

◆ Vector3bP

using momentum::Vector3bP = typedef drjit::Array<ByteP, 3>

Definition at line 67 of file simd.h.

◆ Vector3d

Definition at line 253 of file types.h.

◆ Vector3dP

Definition at line 58 of file simd.h.

◆ Vector3f

Definition at line 243 of file types.h.

◆ Vector3fP

Definition at line 55 of file simd.h.

◆ Vector3i

Definition at line 285 of file types.h.

◆ Vector3iP

using momentum::Vector3iP = typedef drjit::Array<IntP, 3>

Definition at line 66 of file simd.h.

◆ Vector3P

Definition at line 52 of file simd.h.

◆ Vector3s

Definition at line 269 of file types.h.

◆ Vector3u

Definition at line 277 of file types.h.

◆ Vector4

Definition at line 230 of file types.h.

◆ Vector4b

Definition at line 262 of file types.h.

◆ Vector4d

Definition at line 254 of file types.h.

◆ Vector4dP

Definition at line 74 of file simd.h.

◆ Vector4f

Definition at line 244 of file types.h.

◆ Vector4fP

Definition at line 73 of file simd.h.

◆ Vector4i

Definition at line 286 of file types.h.

◆ Vector4P

4D vector types.

Definition at line 71 of file simd.h.

◆ Vector4s

Definition at line 270 of file types.h.

◆ Vector4u

Definition at line 278 of file types.h.

◆ Vector5

Definition at line 232 of file types.h.

◆ Vector5b

Definition at line 263 of file types.h.

◆ Vector5d

Definition at line 255 of file types.h.

◆ Vector5f

Definition at line 245 of file types.h.

◆ Vector5i

Definition at line 287 of file types.h.

◆ Vector5s

Definition at line 271 of file types.h.

◆ Vector5u

Definition at line 279 of file types.h.

◆ Vector6

Definition at line 234 of file types.h.

◆ Vector6b

Definition at line 264 of file types.h.

◆ Vector6d

Definition at line 256 of file types.h.

◆ Vector6f

Definition at line 246 of file types.h.

◆ Vector6i

Definition at line 288 of file types.h.

◆ Vector6s

Definition at line 272 of file types.h.

◆ Vector6u

Definition at line 280 of file types.h.

◆ Vector7

Definition at line 236 of file types.h.

◆ Vector7f

Definition at line 247 of file types.h.

◆ Vector8

Definition at line 238 of file types.h.

◆ Vector8f

Definition at line 248 of file types.h.

◆ Vectorb

template<int Dim>
using momentum::Vectorb = typedef Vector<std::uint8_t, Dim>

Definition at line 213 of file types.h.

◆ Vectord

Definition at line 211 of file types.h.

◆ Vectorf

Definition at line 209 of file types.h.

◆ Vectori

template<int Dim>
using momentum::Vectori = typedef Vector<std::int32_t, Dim>

Definition at line 219 of file types.h.

◆ VectorP

template<typename T , int Dim>
using momentum::VectorP = typedef drjit::Array<Packet<T>, Dim>

Definition at line 46 of file simd.h.

◆ Vectors

template<int Dim>
using momentum::Vectors = typedef Vector<std::uint16_t, Dim>

Definition at line 215 of file types.h.

◆ Vectoru

template<int Dim>
using momentum::Vectoru = typedef Vector<std::uint32_t, Dim>

Definition at line 217 of file types.h.

◆ VectorX

Definition at line 199 of file types.h.

◆ VectorXb

Definition at line 203 of file types.h.

◆ VectorXd

Definition at line 202 of file types.h.

◆ VectorXf

Definition at line 201 of file types.h.

◆ VectorXi

Definition at line 206 of file types.h.

◆ VectorXs

Definition at line 204 of file types.h.

◆ VectorXu

Definition at line 205 of file types.h.

◆ VelocityMagnitudeSequenceErrorFunction

◆ VelocityMagnitudeSequenceErrorFunction_const_p

◆ VelocityMagnitudeSequenceErrorFunction_const_u

◆ VelocityMagnitudeSequenceErrorFunction_const_w

◆ VelocityMagnitudeSequenceErrorFunction_p

◆ VelocityMagnitudeSequenceErrorFunction_u

◆ VelocityMagnitudeSequenceErrorFunction_w

◆ VelocityMagnitudeSequenceErrorFunctiond

◆ VelocityMagnitudeSequenceErrorFunctiond_const_p

◆ VelocityMagnitudeSequenceErrorFunctiond_const_u

◆ VelocityMagnitudeSequenceErrorFunctiond_const_w

◆ VelocityMagnitudeSequenceErrorFunctiond_p

◆ VelocityMagnitudeSequenceErrorFunctiond_u

◆ VelocityMagnitudeSequenceErrorFunctiond_w

◆ VertexArray

Definition at line 395 of file types.h.

◆ VertexConstraint

◆ VertexConstraint_const_p

Definition at line 253 of file fwd.h.

◆ VertexConstraint_const_u

Definition at line 254 of file fwd.h.

◆ VertexConstraint_const_w

Definition at line 255 of file fwd.h.

◆ VertexConstraint_p

Definition at line 250 of file fwd.h.

◆ VertexConstraint_u

Definition at line 251 of file fwd.h.

◆ VertexConstraint_w

Definition at line 252 of file fwd.h.

◆ VertexConstraintd

◆ VertexConstraintd_const_p

Definition at line 260 of file fwd.h.

◆ VertexConstraintd_const_u

Definition at line 261 of file fwd.h.

◆ VertexConstraintd_const_w

Definition at line 262 of file fwd.h.

◆ VertexConstraintd_p

Definition at line 257 of file fwd.h.

◆ VertexConstraintd_u

Definition at line 258 of file fwd.h.

◆ VertexConstraintd_w

Definition at line 259 of file fwd.h.

◆ VertexErrorFunction

◆ VertexErrorFunction_const_p

Definition at line 883 of file fwd.h.

◆ VertexErrorFunction_const_u

Definition at line 884 of file fwd.h.

◆ VertexErrorFunction_const_w

Definition at line 885 of file fwd.h.

◆ VertexErrorFunction_p

Definition at line 880 of file fwd.h.

◆ VertexErrorFunction_u

Definition at line 881 of file fwd.h.

◆ VertexErrorFunction_w

Definition at line 882 of file fwd.h.

◆ VertexErrorFunctiond

◆ VertexErrorFunctiond_const_p

Definition at line 890 of file fwd.h.

◆ VertexErrorFunctiond_const_u

Definition at line 891 of file fwd.h.

◆ VertexErrorFunctiond_const_w

◆ VertexErrorFunctiond_p

Definition at line 887 of file fwd.h.

◆ VertexErrorFunctiond_u

Definition at line 888 of file fwd.h.

◆ VertexErrorFunctiond_w

Definition at line 889 of file fwd.h.

◆ VertexProjectionConstraint

◆ VertexProjectionConstraint_const_p

◆ VertexProjectionConstraint_const_u

◆ VertexProjectionConstraint_const_w

◆ VertexProjectionConstraint_p

Definition at line 269 of file fwd.h.

◆ VertexProjectionConstraint_u

Definition at line 270 of file fwd.h.

◆ VertexProjectionConstraint_w

◆ VertexProjectionConstraintd

◆ VertexProjectionConstraintd_const_p

◆ VertexProjectionConstraintd_const_u

◆ VertexProjectionConstraintd_const_w

◆ VertexProjectionConstraintd_p

◆ VertexProjectionConstraintd_u

◆ VertexProjectionConstraintd_w

◆ VertexProjectionErrorFunction

◆ VertexProjectionErrorFunction_const_p

◆ VertexProjectionErrorFunction_const_u

◆ VertexProjectionErrorFunction_const_w

◆ VertexProjectionErrorFunction_p

◆ VertexProjectionErrorFunction_u

◆ VertexProjectionErrorFunction_w

◆ VertexProjectionErrorFunctiond

◆ VertexProjectionErrorFunctiond_const_p

◆ VertexProjectionErrorFunctiond_const_u

◆ VertexProjectionErrorFunctiond_const_w

◆ VertexProjectionErrorFunctiond_p

◆ VertexProjectionErrorFunctiond_u

◆ VertexProjectionErrorFunctiond_w

◆ VertexSequenceErrorFunction

◆ VertexSequenceErrorFunction_const_p

◆ VertexSequenceErrorFunction_const_u

◆ VertexSequenceErrorFunction_const_w

◆ VertexSequenceErrorFunction_p

◆ VertexSequenceErrorFunction_u

◆ VertexSequenceErrorFunction_w

◆ VertexSequenceErrorFunctiond

◆ VertexSequenceErrorFunctiond_const_p

◆ VertexSequenceErrorFunctiond_const_u

◆ VertexSequenceErrorFunctiond_const_w

◆ VertexSequenceErrorFunctiond_p

◆ VertexSequenceErrorFunctiond_u

◆ VertexSequenceErrorFunctiond_w

◆ VertexVertexDistanceErrorFunction

◆ VertexVertexDistanceErrorFunction_const_p

◆ VertexVertexDistanceErrorFunction_const_u

◆ VertexVertexDistanceErrorFunction_const_w

◆ VertexVertexDistanceErrorFunction_p

◆ VertexVertexDistanceErrorFunction_u

◆ VertexVertexDistanceErrorFunction_w

◆ VertexVertexDistanceErrorFunctiond

◆ VertexVertexDistanceErrorFunctiond_const_p

◆ VertexVertexDistanceErrorFunctiond_const_u

◆ VertexVertexDistanceErrorFunctiond_const_w

◆ VertexVertexDistanceErrorFunctiond_p

◆ VertexVertexDistanceErrorFunctiond_u

◆ VertexVertexDistanceErrorFunctiond_w

◆ WeightMatrix

using momentum::WeightMatrix = typedef Eigen::Matrix<float, Eigen::Dynamic, kMaxSkinJoints, Eigen::AutoAlign | Eigen::RowMajor>

Matrix type for storing weights of joint influences on each vertex.

Each row represents a vertex, and each column represents the weight of a joint influence. The matrix has a fixed number of columns (kMaxSkinJoints) and a dynamic number of rows.

Definition at line 32 of file skin_weights.h.

Enumeration Type Documentation

◆ CharacterFormat

Represents the supported character formats.

Enumerator
Fbx 

FBX file format.

Gltf 

glTF file format.

Usd 

USD file format.

Unknown 

Unknown or unsupported file format.

Definition at line 24 of file character_io.h.

◆ EulerConvention

The Euler angles convention.

Enumerator
Intrinsic 

The intrinsic convention.

Intrinsic rotations (also called local, relative, or body-fixed rotations) are performed around the axes of the coordinate system that is attached to the rotating object.

Intrinsic rotations are usually represented by a sequence of three letters, like XYZ, which means rotation around the X-axis, followed by rotation around the Y-axis, and finally rotation around the Z-axis. For example, intrinsic XYZ is equivalent to RotX(a) * RotY(b) * RotZ(c).

Extrinsic 

The extrinsic convention.

Extrinsic rotations (also called global, absolute, or space-fixed rotations) are performed around the axes of a fixed coordinate system.

Extrinsic rotations are often represented by uppercase letters, like XYZ, which means rotation around the fixed X-axis, followed by rotation around the fixed Y-axis, and finally rotation around the fixed Z-axis. For example, extrinsic XYZ is equivalent to RotZ(c) * RotY(b) * RotX(a).

Definition at line 136 of file utility.h.

◆ FbxCoordSystem

Specifies the third vector of the system.

Maps to fbxsdk::FbxAxisSystem::ECoordSystem

Enumerator
RightHanded 
LeftHanded 

Definition at line 50 of file file_save_options.h.

◆ FbxFrontVector

Vector with origin at the screen pointing toward the camera.

This is a subset of enum EUpVector because axis cannot be repeated. We use the system of "parity" to define this vector because its value (X,Y or Z axis) really depends on the up-vector. Maps to fbxsdk::FbxAxisSystem::EFrontVector

Enumerator
ParityEven 
ParityOdd 

Definition at line 46 of file file_save_options.h.

◆ FbxUpVector

Specifies which canonical axis represents up in the system (typically Y or Z).

Maps to fbxsdk::FbxAxisSystem::EUpVector

Enumerator
XAxis 
YAxis 
ZAxis 

Definition at line 39 of file file_save_options.h.

◆ GltfFileFormat

File format in which the character is saved.

Enumerator
Auto 
Binary 
Ascii 

Definition at line 27 of file file_save_options.h.

◆ JointParameterNames

Enumerator
TX 
TY 
TZ 
RX 
RY 
RZ 
SC 

Definition at line 26 of file types.h.

◆ KeepLocators

Enumerator
No 
Yes 

Definition at line 23 of file fbx_io.h.

◆ LimitType

Enumerator
MinMax 
MinMaxJoint 
MinMaxJointPassive 
Linear 
LinearJoint 
Ellipsoid 
HalfPlane 
LimitTypeCount 

Definition at line 20 of file parameter_limits.h.

◆ LoadBlendShapes

Enumerator
No 
Yes 

Definition at line 26 of file fbx_io.h.

◆ LocatorSpace

Enumerator
Local 
Global 

Definition at line 18 of file locator_io.h.

◆ LogLevel

Logging levels in descending order of verbosity.

Enumerator
Disabled 
Error 
Warning 
Info 
Debug 
Trace 

Definition at line 156 of file log.h.

◆ Permissive

Enumerator
No 
Yes 

Definition at line 20 of file file_save_options.h.

◆ RotationErrorType

Defines different methods for computing rotation error between two quaternions.

Enumerator
RotationMatrixDifference 

Frobenius norm of rotation matrix difference: ||R1 - R2||_F^2.

This is the default method. It computes the squared Frobenius norm of the difference between two rotation matrices. While not a geodesic distance, it has smooth derivatives everywhere and is computationally efficient.

QuaternionLogMap 

Logarithmic map of relative rotation: ||log(R1^{-1} * R2)||^2.

This method computes the squared norm of the logarithmic map of the relative rotation quaternion. This gives the squared geodesic distance on SO(3), which has a clear geometric interpretation. It uses numerically robust logmap computation with Taylor series for small angles.

Definition at line 17 of file state_error_function.h.

◆ Unit

An enumeration representing the units of measurement used in marker data files.

Enumerator

Meters.

DM 

Decimeter.

CM 

Centimeters.

MM 

Millimeters.

Unknown 

Unknown unit of measurement.

Definition at line 22 of file coordinate_system.h.

◆ UpVector

This enumeration is used to define the primary up vector directions for various coordinate systems and orientations in a 3D environment.

Enumerator

X-axis up vector.

Y-axis up vector.

Z-axis up vector.

YNeg 

Negative Y-axis up vector.

Definition at line 14 of file coordinate_system.h.

◆ VertexConstraintType

Enumerator
Position 
Plane 
Normal 
SymmetricNormal 

Definition at line 35 of file vertex_error_function.h.

Function Documentation

◆ addBlendShapeParameters()

std::tuple< ParameterTransform, ParameterLimits > momentum::addBlendShapeParameters ( ParameterTransform  paramTransform,
ParameterLimits  paramLimits,
Eigen::Index  nBlendShapes 
)

◆ addCalibrationOptions()

void momentum::addCalibrationOptions ( CLI::App &  app,
std::shared_ptr< CalibrationConfig config 
)

Definition at line 44 of file app_utils.cpp.

◆ addFaceExpressionParameters()

std::tuple< ParameterTransform, ParameterLimits > momentum::addFaceExpressionParameters ( ParameterTransform  paramTransform,
ParameterLimits  paramLimits,
Eigen::Index  nFaceExpressionBlendShapes 
)

◆ addIOOptions()

void momentum::addIOOptions ( CLI::App &  app,
std::shared_ptr< IOOptions ioOptions 
)

Definition at line 26 of file app_utils.cpp.

◆ addModelOptions()

void momentum::addModelOptions ( CLI::App &  app,
std::shared_ptr< ModelOptions modelOptions 
)

Definition at line 35 of file app_utils.cpp.

◆ addRefineOptions()

void momentum::addRefineOptions ( CLI::App &  app,
std::shared_ptr< RefineConfig config 
)

Definition at line 131 of file app_utils.cpp.

References addTrackingOptions().

◆ addSkinnedLocatorParameters()

std::tuple< ParameterTransform, ParameterLimits > momentum::addSkinnedLocatorParameters ( ParameterTransform  paramTransform,
ParameterLimits  paramLimits,
const std::vector< bool > &  activeLocators,
const std::vector< std::string > &  locatorNames = {} 
)

Add a set of parameters that control the rest-space positions of the skinned locators.

This function will add 3 parameters for each locator, one for each of the x, y, and z components of the locator position. The parameters are added to the end of the parameter transform. The parameter transform is returned along with the updated list of parameter limits. Note that you pass in the locator names rather than the actual SkinnedLocator objects because this avoids a circular dependency.

Definition at line 613 of file parameter_transform.cpp.

References MT_CHECK, and subsetParameterTransform().

Referenced by addSkinnedLocatorParametersToTransform().

◆ addSkinnedLocatorParametersToTransform()

◆ addTrackingOptions()

void momentum::addTrackingOptions ( CLI::App &  app,
std::shared_ptr< TrackingConfig config 
)

Definition at line 100 of file app_utils.cpp.

Referenced by addRefineOptions().

◆ aligned_free()

void momentum::aligned_free ( void ptr)
inline

◆ aligned_malloc()

void * momentum::aligned_malloc ( size_t  size,
size_t  align 
)
inline

Definition at line 42 of file aligned.h.

Referenced by alignedAlloc().

◆ alignedAlloc()

template<typename T , std::size_t Alignment = alignof(T)>
T * momentum::alignedAlloc ( std::size_t  n)

Allocates a block of memory that can hold n elements of type T with the specified alignment.

This function is intended to be used in the AlignedAllocator::allocate() method and throws exceptions as std::allocator<T>::allocate does.

Definition at line 62 of file aligned.h.

References aligned_malloc(), MT_THROW_IF_T, and roundUpToAlignment().

◆ allParams()

ParameterSet momentum::allParams ( )
inline

Creates a ParameterSet with all parameters set to active.

Definition at line 37 of file utility.h.

Referenced by momentum::SequenceSolverFunctionT< T >::SequenceSolverFunctionT().

◆ applyInverseSSD() [1/2]

std::vector< Vector3f > momentum::applyInverseSSD ( const TransformationList inverseBindPose,
const SkinWeights skin,
std::span< const Vector3f points,
const SkeletonState state 
)

Applies inverse SSD to points, returning new points in bind pose space.

This overload transforms points from skinned space back to bind pose space, returning a new vector of transformed points.

Parameters
inverseBindPoseInverse bind pose transformations for each joint
skinSkin weights defining influence of each joint on vertices
pointsInput points to transform (in skinned space)
stateCurrent skeleton state containing joint transformations
Returns
Vector of transformed points in bind pose space

Definition at line 353 of file linear_skinning.cpp.

References applyInverseSSD(), kMaxSkinJoints, and MT_CHECK.

◆ applyInverseSSD() [2/2]

void momentum::applyInverseSSD ( const TransformationList inverseBindPose,
const SkinWeights skin,
std::span< const Vector3f points,
const SkeletonState state,
Mesh mesh 
)

Applies inverse SSD to points, storing results in a mesh.

This overload transforms points from skinned space back to bind pose space, writing the results directly to the provided mesh's vertices.

Parameters
inverseBindPoseInverse bind pose transformations for each joint
skinSkin weights defining influence of each joint on vertices
pointsInput points to transform (in skinned space)
stateCurrent skeleton state containing joint transformations
meshOutput mesh to store the transformed vertices

Definition at line 342 of file linear_skinning.cpp.

References applyInverseSSD(), MT_CHECK, and momentum::MeshT< T >::vertices.

Referenced by applyInverseSSD(), and applyInverseSSD().

◆ applyPassiveJointParameterLimits()

JointParameters momentum::applyPassiveJointParameterLimits ( const ParameterLimits limits,
const JointParameters jointParams 
)

Only processes MinMaxJointPassive limits, clamping parameters to their ranges.

Definition at line 39 of file parameter_limits.cpp.

References kParametersPerJoint, limits, MinMaxJointPassive, and MT_CHECK.

Referenced by momentum::CharacterStateT< T >::set().

◆ applySSD() [1/10]

template<typename T >
void momentum::applySSD ( const SkinWeights skin,
const MeshT< T > &  mesh,
typename DeduceSpanType< const Eigen::Matrix4< T > >::type  skinningTransforms,
MeshT< T > &  outputMesh 
)

Applies forward SSD to a mesh using precomputed skinning transforms.

This is the core mesh skinning function that applies precomputed transformation matrices to transform both vertices and normals from bind pose to animated pose.

Parameters
skinSkin weights defining influence of each joint on vertices
meshInput mesh to transform
skinningTransformsPrecomputed skinning transformation matrices
outputMeshOutput mesh to store the transformed result

Definition at line 158 of file linear_skinning.cpp.

References applySSD(), momentum::MeshT< T >::faces, MT_CHECK, MT_PROFILE_FUNCTION, momentum::MeshT< T >::normals, and momentum::MeshT< T >::vertices.

◆ applySSD() [2/10]

template<typename T >
std::vector< Vector3< T > > momentum::applySSD ( const SkinWeights skin,
typename DeduceSpanType< const Vector3< T > >::type  points,
typename DeduceSpanType< const Eigen::Matrix4< T > >::type  skinningTransforms 
)

Applies forward SSD (linear blend skinning) to points using precomputed skinning transforms.

This is the core skinning function that applies precomputed transformation matrices to transform points from bind pose to animated pose.

Parameters
skinSkin weights defining influence of each joint on vertices
pointsInput points to transform
skinningTransformsPrecomputed skinning transformation matrices
Returns
Vector of transformed points

Definition at line 39 of file linear_skinning.cpp.

References MT_CHECK, and MT_PROFILE_FUNCTION.

Referenced by applySSD(), applySSD(), applySSD(), applySSD(), applySSD(), applySSD(), applySSD(), applySSD(), applySSD(), momentum::CharacterT< T >::bake(), momentum::CharacterStateT< T >::set(), and momentum::MeshStateT< T >::update().

◆ applySSD() [3/10]

template<typename T >
void momentum::applySSD ( const TransformationListT< T > &  inverseBindPose,
const SkinWeights skin,
const MeshT< T > &  mesh,
const SkeletonStateT< T > &  state,
MeshT< T > &  outputMesh 
)

Applies forward SSD to a mesh using skeleton state, modifying output mesh.

This overload transforms both vertices and normals of the mesh, writing results to outputMesh. Use this when working with complete meshes and full skeleton state.

Parameters
inverseBindPoseInverse bind pose transformations for each joint
skinSkin weights defining influence of each joint on vertices
meshInput mesh to transform
stateCurrent skeleton state containing joint transformations
outputMeshOutput mesh to store the transformed result

Definition at line 251 of file linear_skinning.cpp.

References applySSD().

◆ applySSD() [4/10]

template<typename T >
void momentum::applySSD ( const TransformationListT< T > &  inverseBindPose,
const SkinWeights skin,
const MeshT< T > &  mesh,
const TransformationListT< T > &  worldTransforms,
MeshT< T > &  outputMesh 
)

Applies forward SSD to a mesh using precomputed world transforms.

This convenience overload accepts world-space transforms directly instead of joint states. Useful when you already have computed world transforms from another source.

Parameters
inverseBindPoseInverse bind pose transformations for each joint
skinSkin weights defining influence of each joint on vertices
meshInput mesh to transform
worldTransformsWorld-space transforms for each joint
outputMeshOutput mesh to store the transformed result

Definition at line 261 of file linear_skinning.cpp.

References applySSD(), and MT_CHECK.

◆ applySSD() [5/10]

template<typename T >
void momentum::applySSD ( const TransformationListT< T > &  inverseBindPose,
const SkinWeights skin,
const MeshT< T > &  mesh,
typename DeduceSpanType< const JointStateT< T > >::type  jointState,
MeshT< T > &  outputMesh 
)

Applies forward SSD to a mesh using joint states, modifying output mesh.

This overload accepts a span of joint states directly. Use this when you have joint transformations but not a complete skeleton state.

Parameters
inverseBindPoseInverse bind pose transformations for each joint
skinSkin weights defining influence of each joint on vertices
meshInput mesh to transform
jointStateSpan of joint states containing transformations
outputMeshOutput mesh to store the transformed result

Definition at line 240 of file linear_skinning.cpp.

References applySSD(), and computeSkinningTransforms().

◆ applySSD() [6/10]

template<typename T >
void momentum::applySSD ( const TransformationListT< T > &  inverseBindPose,
const SkinWeights skin,
const MeshT< T > &  mesh,
typename DeduceSpanType< const TransformT< T > >::type  worldTransforms,
MeshT< T > &  outputMesh 
)

Applies forward SSD to a mesh using a span of world transforms.

This overload accepts world-space transforms as a span for greater flexibility. Useful when you have transforms in a contiguous array that isn't a std::vector.

Parameters
inverseBindPoseInverse bind pose transformations for each joint
skinSkin weights defining influence of each joint on vertices
meshInput mesh to transform
worldTransformsSpan of world-space transforms for each joint
outputMeshOutput mesh to store the transformed result

Definition at line 281 of file linear_skinning.cpp.

References applySSD(), and MT_CHECK.

◆ applySSD() [7/10]

template<typename T >
std::vector< Vector3< T > > momentum::applySSD ( const TransformationListT< T > &  inverseBindPose,
const SkinWeights skin,
typename DeduceSpanType< const Vector3< T > >::type  points,
const SkeletonStateT< T > &  state 
)

Applies forward SSD to points using skeleton state, returning new points.

This overload transforms individual points using the full skeleton state. Convenience wrapper that extracts joint states from the skeleton state.

Parameters
inverseBindPoseInverse bind pose transformations for each joint
skinSkin weights defining influence of each joint on vertices
pointsInput points to transform
stateCurrent skeleton state containing joint transformations
Returns
Vector of transformed points

Definition at line 111 of file linear_skinning.cpp.

References applySSD().

◆ applySSD() [8/10]

template<typename T >
std::vector< Vector3< T > > momentum::applySSD ( const TransformationListT< T > &  inverseBindPose,
const SkinWeights skin,
typename DeduceSpanType< const Vector3< T > >::type  points,
const TransformationListT< T > &  worldTransforms 
)

Applies forward SSD to points using precomputed world transforms, returning new points.

This convenience overload accepts world-space transforms directly instead of joint states. Useful when you already have computed world transforms from another source.

Parameters
inverseBindPoseInverse bind pose transformations for each joint
skinSkin weights defining influence of each joint on vertices
pointsInput points to transform
worldTransformsWorld-space transforms for each joint
Returns
Vector of transformed points

Definition at line 120 of file linear_skinning.cpp.

References applySSD(), and MT_CHECK.

◆ applySSD() [9/10]

template<typename T >
std::vector< Vector3< T > > momentum::applySSD ( const TransformationListT< T > &  inverseBindPose,
const SkinWeights skin,
typename DeduceSpanType< const Vector3< T > >::type  points,
typename DeduceSpanType< const JointStateT< T > >::type  jointState 
)

Applies forward SSD to points using joint states, returning new points.

This overload transforms individual points and returns a new vector of transformed points. Use this when you need to transform arbitrary points without modifying a mesh.

Parameters
inverseBindPoseInverse bind pose transformations for each joint
skinSkin weights defining influence of each joint on vertices
pointsInput points to transform
jointStateSpan of joint states containing current transformations
Returns
Vector of transformed points

Definition at line 101 of file linear_skinning.cpp.

References applySSD().

◆ applySSD() [10/10]

template<typename T >
std::vector< Vector3< T > > momentum::applySSD ( const TransformationListT< T > &  inverseBindPose,
const SkinWeights skin,
typename DeduceSpanType< const Vector3< T > >::type  points,
typename DeduceSpanType< const TransformT< T > >::type  worldTransforms 
)

Applies forward SSD to points using a span of world transforms, returning new points.

This overload accepts world-space transforms as a span for greater flexibility. Useful when you have transforms in a contiguous array that isn't a std::vector.

Parameters
inverseBindPoseInverse bind pose transformations for each joint
skinSkin weights defining influence of each joint on vertices
pointsInput points to transform
worldTransformsSpan of world-space transforms for each joint
Returns
Vector of transformed points

Definition at line 139 of file linear_skinning.cpp.

References applySSD(), and MT_CHECK.

◆ applySSD< double >() [1/10]

template void momentum::applySSD< double > ( const SkinWeights skin,
const MeshT< double > &  mesh,
std::span< const Eigen::Matrix4d >  skinningTransforms,
MeshT< double > &  outputMesh 
)

◆ applySSD< double >() [2/10]

template std::vector< Vector3d > momentum::applySSD< double > ( const SkinWeights skin,
std::span< const Vector3d points,
std::span< const Eigen::Matrix4d >  skinningTransforms 
)

◆ applySSD< double >() [3/10]

template void momentum::applySSD< double > ( const TransformationListT< double > &  inverseBindPose,
const SkinWeights skin,
const MeshT< double > &  mesh,
const SkeletonStateT< double > &  state,
MeshT< double > &  outputMesh 
)

◆ applySSD< double >() [4/10]

template void momentum::applySSD< double > ( const TransformationListT< double > &  inverseBindPose,
const SkinWeights skin,
const MeshT< double > &  mesh,
const TransformationListT< double > &  worldTransforms,
MeshT< double > &  outputMesh 
)

◆ applySSD< double >() [5/10]

template void momentum::applySSD< double > ( const TransformationListT< double > &  inverseBindPose,
const SkinWeights skin,
const MeshT< double > &  mesh,
std::span< const JointStateT< double > >  jointState,
MeshT< double > &  outputMesh 
)

◆ applySSD< double >() [6/10]

template void momentum::applySSD< double > ( const TransformationListT< double > &  inverseBindPose,
const SkinWeights skin,
const MeshT< double > &  mesh,
std::span< const TransformT< double > >  worldTransforms,
MeshT< double > &  outputMesh 
)

◆ applySSD< double >() [7/10]

template std::vector< Vector3d > momentum::applySSD< double > ( const TransformationListT< double > &  inverseBindPose,
const SkinWeights skin,
std::span< const Vector3d points,
const SkeletonStateT< double > &  state 
)

◆ applySSD< double >() [8/10]

template std::vector< Vector3d > momentum::applySSD< double > ( const TransformationListT< double > &  inverseBindPose,
const SkinWeights skin,
std::span< const Vector3d points,
const TransformationListT< double > &  worldTransforms 
)

◆ applySSD< double >() [9/10]

template std::vector< Vector3d > momentum::applySSD< double > ( const TransformationListT< double > &  inverseBindPose,
const SkinWeights skin,
std::span< const Vector3d points,
std::span< const JointStateT< double > >  jointState 
)

◆ applySSD< double >() [10/10]

template std::vector< Vector3d > momentum::applySSD< double > ( const TransformationListT< double > &  inverseBindPose,
const SkinWeights skin,
std::span< const Vector3d points,
std::span< const TransformT< double > >  worldTransforms 
)

◆ applySSD< float >() [1/10]

template void momentum::applySSD< float > ( const SkinWeights skin,
const MeshT< float > &  mesh,
std::span< const Eigen::Matrix4f >  skinningTransforms,
MeshT< float > &  outputMesh 
)

◆ applySSD< float >() [2/10]

template std::vector< Vector3f > momentum::applySSD< float > ( const SkinWeights skin,
std::span< const Vector3f points,
std::span< const Eigen::Matrix4f >  skinningTransforms 
)

◆ applySSD< float >() [3/10]

template void momentum::applySSD< float > ( const TransformationListT< float > &  inverseBindPose,
const SkinWeights skin,
const MeshT< float > &  mesh,
const SkeletonStateT< float > &  state,
MeshT< float > &  outputMesh 
)

◆ applySSD< float >() [4/10]

template void momentum::applySSD< float > ( const TransformationListT< float > &  inverseBindPose,
const SkinWeights skin,
const MeshT< float > &  mesh,
const TransformationListT< float > &  worldTransforms,
MeshT< float > &  outputMesh 
)

◆ applySSD< float >() [5/10]

template void momentum::applySSD< float > ( const TransformationListT< float > &  inverseBindPose,
const SkinWeights skin,
const MeshT< float > &  mesh,
std::span< const JointStateT< float > >  jointState,
MeshT< float > &  outputMesh 
)

◆ applySSD< float >() [6/10]

template void momentum::applySSD< float > ( const TransformationListT< float > &  inverseBindPose,
const SkinWeights skin,
const MeshT< float > &  mesh,
std::span< const TransformT< float > >  worldTransforms,
MeshT< float > &  outputMesh 
)

◆ applySSD< float >() [7/10]

template std::vector< Vector3f > momentum::applySSD< float > ( const TransformationListT< float > &  inverseBindPose,
const SkinWeights skin,
std::span< const Vector3f points,
const SkeletonStateT< float > &  state 
)

◆ applySSD< float >() [8/10]

template std::vector< Vector3f > momentum::applySSD< float > ( const TransformationListT< float > &  inverseBindPose,
const SkinWeights skin,
std::span< const Vector3f points,
const TransformationListT< float > &  worldTransforms 
)

◆ applySSD< float >() [9/10]

template std::vector< Vector3f > momentum::applySSD< float > ( const TransformationListT< float > &  inverseBindPose,
const SkinWeights skin,
std::span< const Vector3f points,
std::span< const JointStateT< float > >  jointState 
)

◆ applySSD< float >() [10/10]

template std::vector< Vector3f > momentum::applySSD< float > ( const TransformationListT< float > &  inverseBindPose,
const SkinWeights skin,
std::span< const Vector3f points,
std::span< const TransformT< float > >  worldTransforms 
)

◆ averageTriangleSkinWeights()

std::pair< Eigen::Vector< uint32_t, kMaxSkinJoints >, Eigen::Vector< float, kMaxSkinJoints > > momentum::averageTriangleSkinWeights ( const Character character,
int  triangleIndex,
const Eigen::Vector3f &  barycentric 
)

◆ blendTransforms() [1/3]

template TransformT< double > momentum::blendTransforms ( std::span< const TransformT< double > >  transforms,
std::span< const double weights 
)

◆ blendTransforms() [2/3]

template TransformT< float > momentum::blendTransforms ( std::span< const TransformT< float > >  transforms,
std::span< const float weights 
)

◆ blendTransforms() [3/3]

template<typename T >
TransformT< T > momentum::blendTransforms ( std::span< const TransformT< T > >  transforms,
std::span< const T weights 
)

Definition at line 96 of file transform.cpp.

◆ buildJetMat()

template<typename T , int Rows, int Cols>
Eigen::Matrix< ceres::Jet< T, Cols *Rows >, Rows, Cols > momentum::buildJetMat ( const Eigen::Matrix< T, Rows, Cols > &  m)

Definition at line 43 of file ceres_utility.h.

◆ buildJetVec()

template<typename T , int N>
Eigen::Matrix< ceres::Jet< T, N >, N, 1 > momentum::buildJetVec ( const Eigen::Matrix< T, N, 1 > &  v)

Definition at line 31 of file ceres_utility.h.

◆ calculateDWorldPos()

template<typename T >
Eigen::Vector3< T > momentum::calculateDWorldPos ( const momentum::Character character,
const SkeletonStateT< T > &  state,
const int  vertexIndex,
const Eigen::Vector3< T > &  d_restPos 
)

◆ calibrateLocators() [1/2]

void momentum::calibrateLocators ( const std::span< const std::vector< Marker > >  markerData,
const CalibrationConfig config,
const ModelParameters identity,
Character character 
)

Calibrate only locator positions with fixed character identity parameters.

This is a specialized calibration function that only solves for locator positions while keeping all other character parameters (scaling, blend shapes) fixed. This is useful when you have reliable identity parameters and only need to fine-tune marker positions.

Parameters
markerDataMarker observations for each frame
configCalibration configuration settings
identityFixed identity parameters (scaling, blend shapes)
characterCharacter model to calibrate (locators modified in-place)

Definition at line 1051 of file marker_tracker.cpp.

References createLocatorCharacter(), extractLocatorsFromCharacter(), momentum::CharacterT< T >::locators, momentum::BaseConfig::minVisPercent, MT_CHECK, MT_LOGI_IF, momentum::ParameterTransformT< T >::numAllModelParameters(), momentum::ParameterTransformT< T >::parameterSets, momentum::CharacterT< T >::parameterTransform, sampleFrames(), trackPosesForFrames(), trackPosesPerframe(), trackSequence(), and momentum::EigenStrongType< Derived, EigenType >::v.

Referenced by processMarkers().

◆ calibrateLocators() [2/2]

void momentum::calibrateLocators ( std::span< const std::vector< momentum::Marker > >  markerData,
const CalibrationConfig config,
const momentum::ModelParameters identity,
momentum::Character character 
)

Calibrate locator offsets of a character from input identity and marker data.

Parameters
[in]markerDataInput marker data.
[in]configSolving options.
[in]identityIdentity parameters of the input character.
[in,out]characterCharacter definition. It provides input locators offsets which will get updated in return. We overwrite the locators in the input character so we don't have to duplicate the character object inside the function.

◆ calibrateModel() [1/2]

◆ calibrateModel() [2/2]

void momentum::calibrateModel ( std::span< const std::vector< momentum::Marker > >  markerData,
const CalibrationConfig config,
momentum::Character character,
momentum::ModelParameters identity,
const std::array< float, 3 > &  regularizerWeights = {0.0f, 0.0f, 0.0f} 
)

Calibrate body proportions and locator offsets of a character from input marker data.

Parameters
[in]markerDataInput marker data.
[in]configSolving options.
[in,out]characterCharacter definition. It provides input locators offsets which will get updated in return.
[in,out]identityInitial identity parameters that get updated in return. It could also hold the pose of the first frame for better initialization for tracking later.
[in]regularizerWeightsRegularizer weights used for global parameters, at each different stage (3 in total) of the calibration. Ideally these weights would increase over stages: in stage 0, 0 or low regularization weight to allow a large change; in stage 1, a small regularization weight to prevent too large of a change; in stage 2, a higher regularization weight to prevent large changes.

◆ cast()

template<typename OtherScalar , template< typename... > class ContainerType, typename ObjectType >
decltype(auto) momentum::cast ( const ContainerType< ObjectType > &  originalContainer)

Casts the scalar type of objects in a container that support the cast<>() method.

Template Parameters
OtherScalarThe target scalar type for the cast.
ContainerTypeThe type of the container.
ObjectTypeThe type of the objects in the original container.
Parameters
originalContainerA container of objects.
Returns
A new container with objects of the scalar type casted to OtherScalar. If OtherScalar matches the original type, the original container is returned.

Definition at line 438 of file types.h.

◆ cast_span() [1/2]

template<typename T >
std::span< const T > momentum::cast_span ( std::span< const std::byte >  bs)

Casts a span of const bytes to a span of a different type.

This function takes a span of const bytes and returns a span of a different type, by reinterpreting the bytes as the new type. This function is useful when working with serialized data or when dealing with raw memory. The function assumes that the size of the new type is an exact multiple of the size of the original span.

Template Parameters
TThe type to cast the span to
Parameters
bsThe original span of const bytes to cast
Returns
A span of the new type, with the same number of elements as the original span

Definition at line 44 of file gsl_utils.h.

◆ cast_span() [2/2]

template<typename T >
std::span< T > momentum::cast_span ( std::span< std::byte >  bs)

Casts a span of bytes to a span of a different type.

This function takes a span of bytes and returns a span of a different type, by reinterpreting the bytes as the new type. This function is useful when working with serialized data or when dealing with raw memory. The function assumes that the size of the new type is an exact multiple of the size of the original span.

Template Parameters
TThe type to cast the span to
Parameters
bsThe original span of bytes to cast
Returns
A span of the new type, with the same number of elements as the original span

Definition at line 26 of file gsl_utils.h.

◆ castMatrices()

template<typename T , typename T2 >
std::vector< Eigen::MatrixX< T2 > > momentum::castMatrices ( std::span< const Eigen::MatrixX< T > >  m_in)

Definition at line 58 of file mppca.cpp.

◆ castVectors()

template<typename T , typename T2 , int N>
std::vector< Eigen::Vector< T2, N > > momentum::castVectors ( const std::vector< Eigen::Vector< T, N > > &  vec_in)

Definition at line 50 of file mesh.cpp.

◆ characterToLegacyJson()

nlohmann::json momentum::characterToLegacyJson ( const Character character)

Converts a Character to legacy JSON object.

Parameters
[in]characterThe Character to convert
Returns
nlohmann::json object containing the legacy JSON representation

Definition at line 580 of file legacy_json_io.cpp.

References momentum::CharacterT< T >::collision, momentum::CharacterT< T >::locators, momentum::CharacterT< T >::mesh, momentum::CharacterT< T >::skeleton, and momentum::CharacterT< T >::skinWeights.

Referenced by characterToLegacyJsonString(), and saveCharacterToLegacyJson().

◆ characterToLegacyJsonString()

std::string momentum::characterToLegacyJsonString ( const Character character)

Converts a Character to legacy JSON string.

Parameters
[in]characterThe Character to convert
Returns
String containing the legacy JSON representation

Definition at line 575 of file legacy_json_io.cpp.

References characterToLegacyJson().

◆ checkAlignment()

template<size_t Alignment>
void momentum::checkAlignment ( const Eigen::Ref< Eigen::MatrixXf > &  mat,
size_t  offset = 0 
)

Checks if the data of the matrix is aligned correctly.

Definition at line 108 of file simd.h.

References MT_THROW_IF.

◆ closestPointOnMeshMatchingParent()

ClosestPointOnMeshResult momentum::closestPointOnMeshMatchingParent ( const momentum::Mesh mesh,
const momentum::SkinWeights skin,
const momentum::Skeleton skeleton,
const Eigen::Vector3f &  p_world,
uint32_t  parentIdx,
float  cutoffWeight = 0.02 
)

◆ closestPointsOnSegments()

template<typename T >
std::tuple< bool, T, Eigen::Vector2< T > > momentum::closestPointsOnSegments ( const Eigen::Vector3< T > &  o1,
const Eigen::Vector3< T > &  d1,
const Eigen::Vector3< T > &  o2,
const Eigen::Vector3< T > &  d2,
T  maxDist = std::numeric_limits< T >::max() 
)

Returns the closest points on two line segments where the line segments are represented in origin and direction.

Template Parameters
TScalar type
Parameters
o1Origin of the first line segment
d1Direction of the first line segment
o2Origin of the second line segment
d2Direction of the second line segment
maxDistMaximum distance to check
Returns
[success, distance, [dist0, dist1]]:
  • success: Whether the closest points were successfully found. On false, the rest return values are invalid.
  • distance: Distance between the closest points
  • [dist0, dist1]: Distances of the closest points from their origins to the directions

Definition at line 434 of file utility.cpp.

References distance.

◆ closestPointsOnSegments< double >()

template std::tuple< bool, double, Eigen::Vector2< double > > momentum::closestPointsOnSegments< double > ( const Eigen::Vector3< double > &  o1,
const Eigen::Vector3< double > &  d1,
const Eigen::Vector3< double > &  o2,
const Eigen::Vector3< double > &  d2,
const double  maxDist 
)

◆ closestPointsOnSegments< float >()

template std::tuple< bool, float, Eigen::Vector2< float > > momentum::closestPointsOnSegments< float > ( const Eigen::Vector3< float > &  o1,
const Eigen::Vector3< float > &  d1,
const Eigen::Vector3< float > &  o2,
const Eigen::Vector3< float > &  d2,
const float  maxDist 
)

◆ compute_d_targetNormal_d_vertexPos() [1/2]

template<typename T >
std::array< Eigen::Matrix3< T >, 3 > momentum::compute_d_targetNormal_d_vertexPos ( const PointTriangleVertexConstraintT< T > &  cons,
const MeshT< T > &  mesh 
)

◆ compute_d_targetNormal_d_vertexPos() [2/2]

template<typename T >
std::array< Eigen::Matrix3< T >, 3 > momentum::compute_d_targetNormal_d_vertexPos ( const SkinnedLocatorTriangleConstraintT< T > &  cons,
const MeshT< T > &  mesh 
)

◆ compute_d_targetPos_d_vertexPos() [1/2]

template<typename T >
std::array< Eigen::Matrix3< T >, 3 > momentum::compute_d_targetPos_d_vertexPos ( const PointTriangleVertexConstraintT< T > &  cons,
const MeshT< T > &  mesh 
)

◆ compute_d_targetPos_d_vertexPos() [2/2]

template<typename T >
std::array< Eigen::Matrix3< T >, 3 > momentum::compute_d_targetPos_d_vertexPos ( const SkinnedLocatorTriangleConstraintT< T > &  cons,
const MeshT< T > &  mesh 
)

◆ computeOffset()

template<size_t Alignment>
size_t momentum::computeOffset ( const Eigen::Ref< Eigen::MatrixXf > &  mat)

Computes the offset required for the matrix data to meet the alignment requirement.

Definition at line 93 of file simd.h.

◆ computeSkinningTransforms()

template<typename T >
std::vector< Eigen::Matrix4< T > > momentum::computeSkinningTransforms ( typename DeduceSpanType< const JointStateT< T > >::type  jointState,
const TransformationListT< T > &  inverseBindPose 
)

Computes the skinning transforms from joint states and inverse bind poses.

This is a helper function that computes the combined transformation matrices used for skinning. Each transform is computed as: jointState.transform * inverseBindPose.

Parameters
jointStateSpan of joint states containing current transformations
inverseBindPoseInverse bind pose transformations for each joint
Returns
Vector of 4x4 transformation matrices for skinning

Definition at line 22 of file linear_skinning.cpp.

References MT_CHECK.

Referenced by applySSD().

◆ computeSkinningTransforms< double >()

template std::vector< Eigen::Matrix4d > momentum::computeSkinningTransforms< double > ( std::span< const JointStateT< double > >  jointState,
const TransformationListT< double > &  inverseBindPose 
)

◆ computeSkinningTransforms< float >()

template std::vector< Eigen::Matrix4f > momentum::computeSkinningTransforms< float > ( std::span< const JointStateT< float > >  jointState,
const TransformationListT< float > &  inverseBindPose 
)

◆ computeSubsetParameterIndices()

template<typename T >
std::vector< Eigen::Index > momentum::computeSubsetParameterIndices ( const ParameterTransformT< T > &  parameterTransform,
const ParameterSet activeParams 
)

◆ computeTargetBaryPosition() [1/2]

◆ computeTargetBaryPosition() [2/2]

template<typename T >
Eigen::Vector3< T > momentum::computeTargetBaryPosition ( const MeshT< T > &  mesh,
const SkinnedLocatorTriangleConstraintT< T > &  c 
)

◆ computeTargetPosition() [1/2]

◆ computeTargetPosition() [2/2]

template<typename T >
Eigen::Vector3< T > momentum::computeTargetPosition ( const MeshT< T > &  mesh,
const SkinnedLocatorTriangleConstraintT< T > &  c 
)

◆ computeTargetTriangleNormal() [1/2]

◆ computeTargetTriangleNormal() [2/2]

template<typename T >
Eigen::Vector3< T > momentum::computeTargetTriangleNormal ( const MeshT< T > &  mesh,
const SkinnedLocatorTriangleConstraintT< T > &  c 
)

◆ copyAccessorBuffer()

template<typename T >
std::vector< T > momentum::copyAccessorBuffer ( const fx::gltf::Document &  model,
int32_t  id 
)

Definition at line 55 of file accessor_utils.h.

References getComponentSize(), getTypeSize(), and MT_LOGW.

◆ copyAlignedAccessorBuffer()

template<typename T >
std::vector< T > momentum::copyAlignedAccessorBuffer ( const fx::gltf::Document &  model,
int32_t  id 
)

Definition at line 89 of file accessor_utils.h.

References getComponentSize(), getTypeSize(), and MT_LOGW.

◆ createAccessorBuffer()

template<typename T >
int32_t momentum::createAccessorBuffer ( fx::gltf::Document &  model,
std::span< T data,
const bool  align = false,
const bool  normalized = false 
)

Definition at line 134 of file accessor_utils.h.

Referenced by createSampler(), and createSampler().

◆ createConstraintData() [1/2]

std::vector< std::vector< PositionData > > momentum::createConstraintData ( const std::span< const std::vector< Marker > >  markerData,
const LocatorList locators 
)

Definition at line 30 of file tracker_utils.cpp.

Referenced by trackPosesForFrames(), and trackSequence().

◆ createConstraintData() [2/2]

std::vector< std::vector< momentum::PositionData > > momentum::createConstraintData ( std::span< const std::vector< momentum::Marker > >  markerData,
const momentum::LocatorList locators 
)

◆ createFloorConstraints()

template<typename T >
std::vector< PlaneDataT< T > > momentum::createFloorConstraints ( const std::string &  prefix,
const LocatorList locators,
const Vector3< T > &  floorNormal,
const T floorOffset,
const float  weight 
)

Create non-penetration half-plane constraints from locators with the input prefix.

Definition at line 18 of file plane_error_function.cpp.

◆ createFloorConstraints< double >()

template std::vector< PlaneDataT< double > > momentum::createFloorConstraints< double > ( const std::string &  prefix,
const LocatorList locators,
const Vector3d floorNormal,
const double floorOffset,
const float  weight 
)

◆ createFloorConstraints< float >()

template std::vector< PlaneDataT< float > > momentum::createFloorConstraints< float > ( const std::string &  prefix,
const LocatorList locators,
const Vector3f floorNormal,
const float floorOffset,
const float  weight 
)

◆ createLocatorCharacter()

◆ createSampler() [1/2]

template<typename T >
int32_t momentum::createSampler ( fx::gltf::Document &  model,
fx::gltf::Animation &  anim,
std::span< T data,
const int32_t  timestampAccessor 
)

Definition at line 288 of file accessor_utils.h.

References createAccessorBuffer().

◆ createSampler() [2/2]

template<typename T >
int32_t momentum::createSampler ( fx::gltf::Document &  model,
fx::gltf::Animation &  anim,
std::span< T data,
const std::span< float > &  timestamps 
)

Definition at line 267 of file accessor_utils.h.

References createAccessorBuffer(), and MT_CHECK.

◆ createSkinnedConstraintData() [1/2]

std::vector< std::vector< SkinnedLocatorConstraint > > momentum::createSkinnedConstraintData ( const std::span< const std::vector< Marker > >  markerData,
const SkinnedLocatorList locators 
)

Definition at line 65 of file tracker_utils.cpp.

Referenced by trackPosesForFrames(), and trackSequence().

◆ createSkinnedConstraintData() [2/2]

std::vector< std::vector< momentum::SkinnedLocatorConstraint > > momentum::createSkinnedConstraintData ( std::span< const std::vector< momentum::Marker > >  markerData,
const momentum::SkinnedLocatorList locators 
)

◆ createSkinnedLocatorMeshConstraints()

◆ cross() [1/2]

template<typename S , typename Derived >
Vector3P< S > momentum::cross ( const Eigen::MatrixBase< Derived > &  v1,
const Vector3P< S > &  v2 
)

Calculates cross product of Eigen::Vector3f and Vector3P.

Template Parameters
DerivedA derived class of Eigen::MatrixBase, which should be compatible with Eigen::Vector3f.
Parameters
[in]v1A 3D vector of Eigen.
[in]v2A 3-vector of packets.

Definition at line 230 of file simd.h.

Referenced by compute_d_targetNormal_d_vertexPos(), compute_d_targetNormal_d_vertexPos(), momentum::SimdNormalErrorFunction::getGradient(), intersectMesh(), intersectMeshBruteForce(), and momentum::MeshT< T >::updateNormals().

◆ cross() [2/2]

template<typename S , typename Derived >
Vector3P< S > momentum::cross ( const Vector3P< S > &  v1,
const Eigen::MatrixBase< Derived > &  v2 
)

Calculates cross product of Vector3P and Eigen::Vector3f.

Template Parameters
DerivedA derived class of Eigen::MatrixBase, which should be compatible with Eigen::Vector3f.
Parameters
[in]v1A 3-vector of packets.
[in]v2A 3D vector of Eigen.

Definition at line 245 of file simd.h.

◆ crossProductMatrix()

template<typename T >
Eigen::Matrix< T, 3, 3 > momentum::crossProductMatrix ( const Eigen::Vector3< T > &  v)

Creates a skew-symmetric matrix for computing cross products.

Returns a matrix M such that M*u = vร—u for any vector u

Template Parameters
TThe scalar type
Parameters
vInput vector
Returns
3ร—3 skew-symmetric matrix

Definition at line 316 of file utility.h.

◆ d_modelParams_d_inputs()

template<typename T >
std::vector< ErrorFunctionDerivativesT< T > > momentum::d_modelParams_d_inputs ( const Skeleton skeleton,
const ParameterTransformT< T > &  parameterTransform,
const ParameterSet activeParams,
const ModelParametersT< T > &  modelParameters,
SkeletonSolverFunctionT< T > &  solverFunction,
Eigen::Ref< const Eigen::VectorX< T > >  dLoss_dModelParams,
T gradientRmse 
)

◆ d_modelParams_d_inputs< double >()

template std::vector< ErrorFunctionDerivativesT< double > > momentum::d_modelParams_d_inputs< double > ( const Skeleton skeleton,
const ParameterTransformT< double > &  parameterTransform,
const ParameterSet activeParams,
const ModelParametersT< double > &  modelParameters,
SkeletonSolverFunctionT< double > &  solverFunction,
Eigen::Ref< const Eigen::VectorX< double > >  dLoss_dModelParams,
double gradientRmse 
)

◆ d_modelParams_d_inputs< float >()

template std::vector< ErrorFunctionDerivativesT< float > > momentum::d_modelParams_d_inputs< float > ( const Skeleton skeleton,
const ParameterTransformT< float > &  parameterTransform,
const ParameterSet activeParams,
const ModelParametersT< float > &  modelParameters,
SkeletonSolverFunctionT< float > &  solverFunction,
Eigen::Ref< const Eigen::VectorX< float > >  dLoss_dModelParams,
float gradientRmse 
)

◆ dot() [1/2]

template<typename Derived , typename S >
FloatP momentum::dot ( const Eigen::MatrixBase< Derived > &  v1,
const Vector3P< S > &  v2 
)

Calculates dot product of Eigen::Vector3f and 3-vector of packets.

Template Parameters
DerivedA derived class of Eigen::MatrixBase, which should be compatible with Eigen::Vector3f.
Parameters
[in]v1A 3D vector of Eigen.
[in]v2A 3-vector of packets.

Definition at line 125 of file simd.h.

Referenced by momentum::SkeletonStateT< T >::compare(), momentum::FixedAxisAngleErrorFunctionT< T >::evalFunction(), momentum::SimdPlaneErrorFunction::getError(), momentum::SimdPositionErrorFunction::getError(), momentum::SimdNormalErrorFunction::getError(), momentum::SimdNormalErrorFunction::getGradient(), and operator*().

◆ dot() [2/2]

template<typename Derived , typename S >
FloatP momentum::dot ( const Vector3P< S > &  v1,
const Eigen::MatrixBase< Derived > &  v2 
)

Calculates dot product of Vector3P and Eigen::Vector3f.

Template Parameters
DerivedA derived class of Eigen::MatrixBase, which should be compatible with Eigen::Vector3f.
Parameters
[in]v1A 3-vector of packets.
[in]v2A 3D vector of Eigen.

Definition at line 136 of file simd.h.

◆ Eps()

template<typename T >
constexpr T momentum::Eps ( T  FloatEps = T(1e-7),
T  DoubleEps = T(1e-16) 
)
constexpr

Returns the tolerance value based on the provided type T.

Definition at line 22 of file constants.h.

◆ eulerToQuaternion() [1/3]

template Quaternion< double > momentum::eulerToQuaternion ( const Vector3< double > &  angles,
int  axis0,
int  axis1,
int  axis2,
EulerConvention  convention 
)

◆ eulerToQuaternion() [2/3]

template Quaternion< float > momentum::eulerToQuaternion ( const Vector3< float > &  angles,
int  axis0,
int  axis1,
int  axis2,
EulerConvention  convention 
)

◆ eulerToQuaternion() [3/3]

template<typename T >
Quaternion< T > momentum::eulerToQuaternion ( const Vector3< T > &  angles,
int  axis0,
int  axis1,
int  axis2,
EulerConvention  convention = EulerConvention::Intrinsic 
)

Converts Euler angles to quaternion.

Template Parameters
TThe scalar type.
Parameters
[in]anglesThe 3-dimensional vector of Euler angles in order.
[in]axis0The index of the first rotation's axis, one of {0, 1, 2}.
[in]axis1The index of the second rotation's axis, one of {0, 1, 2}.
[in]axis2The index of the third rotation's axis, one of {0, 1, 2}.
[in]conventionThe Euler angles convention.

Definition at line 291 of file utility.cpp.

References eulerToQuaternion(), Extrinsic, and Intrinsic.

Referenced by eulerToQuaternion().

◆ eulerToRotationMatrix() [1/3]

template Matrix3< double > momentum::eulerToRotationMatrix ( const Vector3< double > &  angles,
int  axis0,
int  axis1,
int  axis2,
EulerConvention  convention 
)

◆ eulerToRotationMatrix() [2/3]

template Matrix3< float > momentum::eulerToRotationMatrix ( const Vector3< float > &  angles,
int  axis0,
int  axis1,
int  axis2,
EulerConvention  convention 
)

◆ eulerToRotationMatrix() [3/3]

template<typename T >
Matrix3< T > momentum::eulerToRotationMatrix ( const Vector3< T > &  angles,
int  axis0,
int  axis1,
int  axis2,
EulerConvention  convention = EulerConvention::Intrinsic 
)

Converts Euler angles to rotation matrix.

Template Parameters
TThe scalar type.
Parameters
[in]anglesThe 3-dimensional vector of Euler angles in order.
[in]axis0The index of the first rotation's axis, one of {0, 1, 2}.
[in]axis1The index of the second rotation's axis, one of {0, 1, 2}.
[in]axis2The index of the third rotation's axis, one of {0, 1, 2}.
[in]conventionThe Euler angles convention.

Definition at line 309 of file utility.cpp.

◆ eulerXYZToRotationMatrix() [1/3]

template Matrix3< double > momentum::eulerXYZToRotationMatrix ( const Vector3< double > &  angles,
EulerConvention  convention 
)

◆ eulerXYZToRotationMatrix() [2/3]

template Matrix3< float > momentum::eulerXYZToRotationMatrix ( const Vector3< float > &  angles,
EulerConvention  convention 
)

◆ eulerXYZToRotationMatrix() [3/3]

template<typename T >
Matrix3< T > momentum::eulerXYZToRotationMatrix ( const Vector3< T > &  angles,
EulerConvention  convention 
)

An optimized version of eulerToRotationMatrix(angles, 0, 1, 2, convention) or eulerToRotationMatrix(angles.reverse(), 2, 1, 0, convention).

Definition at line 319 of file utility.cpp.

References eulerZYXToRotationMatrix(), Extrinsic, and Intrinsic.

Referenced by eulerZYXToRotationMatrix().

◆ eulerZYXToRotationMatrix() [1/3]

template Matrix3< double > momentum::eulerZYXToRotationMatrix ( const Vector3< double > &  angles,
EulerConvention  convention 
)

◆ eulerZYXToRotationMatrix() [2/3]

template Matrix3< float > momentum::eulerZYXToRotationMatrix ( const Vector3< float > &  angles,
EulerConvention  convention 
)

◆ eulerZYXToRotationMatrix() [3/3]

template<typename T >
Matrix3< T > momentum::eulerZYXToRotationMatrix ( const Vector3< T > &  angles,
EulerConvention  convention 
)

An optimized version of eulerToRotationMatrix(angles, 2, 1, 0, convention) or eulerToRotationMatrix(angles.reverse(), 0, 1, 2, convention).

Definition at line 353 of file utility.cpp.

References eulerXYZToRotationMatrix(), Extrinsic, and Intrinsic.

Referenced by eulerXYZToRotationMatrix().

◆ extractBlendShapeFromParams()

Mesh momentum::extractBlendShapeFromParams ( const momentum::ModelParameters param,
const momentum::Character sourceCharacter 
)

◆ extractBlendWeights()

template<typename T >
BlendWeightsT< T > momentum::extractBlendWeights ( const ParameterTransform paramTransform,
const ModelParametersT< T > &  modelParams 
)

Extracts blend shape weights from model parameters.

Maps from the model parameter space to blend shape weights using the parameter transform. Use this function to get weights for identity/shape blend shapes (e.g., body shape variations).

Parameters
paramTransformMapping between model parameters and blend shape parameters
modelParamsCurrent model parameters
Returns
Vector of blend shape weights

Definition at line 22 of file blend_shape_skinning.cpp.

References momentum::EigenStrongType< Derived, EigenType >::size().

Referenced by momentum::CharacterT< T >::bake(), momentum::CharacterT< T >::bakeBlendShape(), calibrateModel(), extractBlendShapeFromParams(), skinWithBlendShapes(), and momentum::MeshStateT< T >::update().

◆ extractBlendWeights< double >()

◆ extractBlendWeights< float >()

◆ extractFaceExpressionBlendWeights()

template<typename T >
BlendWeightsT< T > momentum::extractFaceExpressionBlendWeights ( const ParameterTransform paramTransform,
const ModelParametersT< T > &  modelParams 
)

Extracts facial expression blend shape weights from model parameters.

Maps from the model parameter space to facial expression blend shape weights using the parameter transform. Use this function specifically for facial animation parameters, which are stored separately from regular blend shapes.

Parameters
paramTransformMapping between model parameters and face expression parameters
modelParamsCurrent model parameters
Returns
Vector of facial expression blend shape weights

Definition at line 36 of file blend_shape_skinning.cpp.

References momentum::EigenStrongType< Derived, EigenType >::size().

Referenced by momentum::MeshStateT< T >::update().

◆ extractFaceExpressionBlendWeights< double >()

◆ extractFaceExpressionBlendWeights< float >()

◆ extractIdAndLocatorsFromParams()

std::tuple< Eigen::VectorXf, momentum::LocatorList, momentum::SkinnedLocatorList > momentum::extractIdAndLocatorsFromParams ( const ModelParameters param,
const Character sourceCharacter,
const Character targetCharacter 
)

◆ extractLocatorsFromCharacter()

momentum::LocatorList momentum::extractLocatorsFromCharacter ( const Character locatorCharacter,
const CharacterParameters calibParams 
)

◆ extractMarkersFromMotion()

std::vector< std::vector< momentum::Marker > > momentum::extractMarkersFromMotion ( const Character character,
const Eigen::MatrixXf &  motion 
)

◆ extractParameters()

momentum::ModelParameters momentum::extractParameters ( const ModelParameters params,
const ParameterSet parameterSet 
)

Definition at line 611 of file tracker_utils.cpp.

Referenced by extractIdAndLocatorsFromParams(), and saveMotion().

◆ extractSkinnedLocatorsFromCharacter()

SkinnedLocatorList momentum::extractSkinnedLocatorsFromCharacter ( const Character locatorCharacter,
const CharacterParameters calibParams 
)

Definition at line 588 of file tracker_utils.cpp.

Referenced by extractIdAndLocatorsFromParams().

◆ extractSubsetMat()

template<typename T >
Eigen::MatrixX< T > momentum::extractSubsetMat ( Eigen::Ref< const Eigen::MatrixX< T > >  fullMat,
const std::vector< Eigen::Index > &  subsetIndexToFullParamIndex 
)

Definition at line 47 of file fully_differentiable_body_ik.cpp.

◆ extractSubsetVec()

template<typename T >
Eigen::VectorX< T > momentum::extractSubsetVec ( Eigen::Ref< const Eigen::VectorX< T > >  fullVec,
const std::vector< Eigen::Index > &  subsetIndexToFullParamIndex 
)

Definition at line 35 of file fully_differentiable_body_ik.cpp.

◆ extrapolateModelParameters() [1/2]

ModelParameters momentum::extrapolateModelParameters ( const ModelParameters previous,
const ModelParameters current,
const ParameterSet activeParams,
float  factor = kDefaultExtrapolateFactor,
float  maxDelta = kDefaultExtrapolateMaxDelta 
)

Extrapolates model parameters considering active parameters.

The extrapolation is done by first clamping the difference between current and previous parameters to the range [-maxDelta, maxDelta] for each active parameter, and then scaling this clamped difference by factor. Returns the current parameters when sizes mismatch.

Definition at line 31 of file skeleton_utility.cpp.

References MT_PROFILE_FUNCTION.

◆ extrapolateModelParameters() [2/2]

ModelParameters momentum::extrapolateModelParameters ( const ModelParameters previous,
const ModelParameters current,
float  factor = kDefaultExtrapolateFactor,
float  maxDelta = kDefaultExtrapolateMaxDelta 
)

Extrapolates model parameters by first clamping the difference between current and previous parameters to the range [-maxDelta, maxDelta], and then scaling this clamped difference by factor.

Returns the current parameters when sizes mismatch.

Definition at line 13 of file skeleton_utility.cpp.

References MT_PROFILE_FUNCTION, and momentum::EigenStrongType< Derived, EigenType >::v.

◆ facesToVertices()

template<typename T >
std::vector< bool > momentum::facesToVertices ( const MeshT< T > &  mesh,
const std::vector< bool > &  activeFaces 
)

Converts face selection to vertex selection.

Parameters
[in]characterCharacter containing the mesh
[in]activeFacesBoolean vector indicating which faces are active
Returns
Boolean vector indicating which vertices are used by active faces

Definition at line 1142 of file character_utility.cpp.

References momentum::MeshT< T >::faces, facesToVertices(), MT_CHECK, and momentum::MeshT< T >::vertices.

Referenced by facesToVertices(), and reduceMeshByFaces().

◆ facesToVertices< double >()

template std::vector< bool > momentum::facesToVertices< double > ( const MeshT< double > &  mesh,
const std::vector< bool > &  activeFaces 
)

◆ facesToVertices< float >()

template std::vector< bool > momentum::facesToVertices< float > ( const MeshT< float > &  mesh,
const std::vector< bool > &  activeFaces 
)

◆ fillIdentity()

void momentum::fillIdentity ( const ParameterSet idSet,
const ModelParameters identity,
Eigen::MatrixXf &  motionNoId 
)

◆ findMainSubjectIndex()

int momentum::findMainSubjectIndex ( std::span< const MarkerSequence markerSequences)

Finds the "main subject" from a vector of MarkerSequences.

The main subject is currently defined as a named actor with the maximum number of visible markers in the sequence.

Parameters
[in]markerSequencesA vector of MarkerSequences to search for the main subject.
Returns
int The main subject's index in the input vector. If no main subject found, -1 is returned.
Note
This function is exposed mainly for unit tests.

Definition at line 69 of file marker_io.cpp.

Referenced by loadMarkersForMainSubject(), and processMarkerFile().

◆ fromJson()

template<typename T >
T momentum::fromJson ( const nlohmann::json &  j)

Definition at line 40 of file json_utils.h.

◆ fromMomentumQuaternionf()

std::array< float, 4 > momentum::fromMomentumQuaternionf ( const Quaternionf quat)
inlinenoexcept

Definition at line 31 of file coordinate_utils.h.

Referenced by momentum::GltfBuilder::addCharacter().

◆ fromMomentumVec3f() [1/3]

Vector3f momentum::fromMomentumVec3f ( const Vector3f vec)
inlinenoexcept

Definition at line 22 of file coordinate_utils.h.

References toM().

Referenced by momentum::GltfBuilder::addCharacter().

◆ fromMomentumVec3f() [2/3]

void momentum::fromMomentumVec3f ( std::vector< Vector3f > &  vec)
inline

Definition at line 44 of file coordinate_utils.h.

References toM().

◆ fromMomentumVec3f() [3/3]

void momentum::fromMomentumVec3f ( VectorXf vec)
inline

Definition at line 52 of file coordinate_utils.h.

References toM().

◆ getAuxiliaryDataFromMotion()

std::tuple< MatrixXf, std::vector< std::string > > momentum::getAuxiliaryDataFromMotion ( const MatrixXf poses,
std::span< const std::string >  parameterNames 
)

Extract auxiliary data from motion parameters.

Auxiliary parameters are identified by names wrapped with double underscores (e.g., "__param__")

Parameters
posesMotion poses matrix
parameterNamesNames of all parameters
Returns
Tuple of (auxiliary data matrix, auxiliary parameter names without underscores)

Definition at line 224 of file mmo_io.cpp.

◆ getComponentSize()

int32_t momentum::getComponentSize ( const fx::gltf::Accessor::ComponentType &  componentType)
inline

Definition at line 17 of file accessor_utils.h.

Referenced by copyAccessorBuffer(), and copyAlignedAccessorBuffer().

◆ getInverseSSDTransformation()

Affine3f momentum::getInverseSSDTransformation ( const TransformationList inverseBindPose,
const SkinWeights skin,
const SkeletonState state,
size_t  index 
)

Computes the inverse SSD transformation for a specific vertex.

Returns a transformation matrix that converts from skinned space back to bind pose space. This is useful for operations that need to work in the original bind pose space.

Parameters
inverseBindPoseInverse bind pose transformations for each joint
skinSkin weights defining influence of each joint on vertices
stateCurrent skeleton state containing joint transformations
indexIndex of the vertex to compute inverse transformation for
Returns
Inverse transformation matrix for the specified vertex

Definition at line 300 of file linear_skinning.cpp.

References getInverseSSDTransformation(), kMaxSkinJoints, and MT_CHECK.

Referenced by getInverseSSDTransformation().

◆ GetLineCrossPlatform()

std::istream & momentum::GetLineCrossPlatform ( std::istream &  is,
std::string &  line 
)

Reads a line from the input stream, handling line endings for different platforms.

This function reads a line from the given input stream and stores it in the 'line' parameter. It properly handles line endings for different platforms (e.g., LF for Unix, CRLF for Windows).

Parameters
[in,out]isReference to the input stream from which the line should be read.
[in,out]lineReference to the string variable where the line will be stored.
Returns
Reference to the input stream after reading the line.

Definition at line 39 of file stream_utils.cpp.

Referenced by loadTrc().

◆ getLocatorError() [1/2]

std::pair< float, float > momentum::getLocatorError ( std::span< const std::vector< momentum::Marker > >  markerData,
const Eigen::MatrixXf &  motion,
momentum::Character character 
)

Get the error of the locator motion vs the markers.

Parameters
[in]markerDataInput marker data.
[in]motionMotion to compare against.
[in]characterCharacter definition
Returns
average per frame error and max marker error

◆ getLocatorError() [2/2]

std::pair< float, float > momentum::getLocatorError ( std::span< const std::vector< momentum::Marker > >  markerData,
const MatrixXf motion,
momentum::Character character 
)

Compute average and maximum marker tracking errors across all frames.

This is a utility function for evaluating tracking quality by measuring the Euclidean distance between observed marker positions and their corresponding locator positions on the character. It provides both average error per frame and the maximum error encountered across all markers and frames.

This function supports both regular locators and skinned locators.

Parameters
markerDataMarker observations for each frame
motionSolved motion parameters matrix (parameters x frames)
characterCharacter model with locators
Returns
Pair of (average_error, max_error) in world units

Definition at line 1221 of file marker_tracker.cpp.

References getSkinnedLocatorPosition(), momentum::CharacterT< T >::inverseBindPose, momentum::CharacterT< T >::locators, MT_CHECK, MT_LOGI, momentum::ParameterTransformT< T >::numAllModelParameters(), momentum::CharacterT< T >::parameterTransform, momentum::SkeletonStateT< T >::set(), momentum::CharacterT< T >::skeleton, and momentum::CharacterT< T >::skinnedLocators.

Referenced by processMarkers().

◆ getLogLevel()

LogLevel momentum::getLogLevel ( )

Definition at line 93 of file log.cpp.

References Debug, Disabled, Error, Info, MT_LOGW, Trace, and Warning.

◆ getPoseConstraintParameterLimits()

ParameterLimits momentum::getPoseConstraintParameterLimits ( const std::string &  name,
const ParameterTransform pt,
const float  weight 
)

◆ getRotationDerivative()

template<typename T , typename T2 >
Eigen::Vector3< T > momentum::getRotationDerivative ( const JointStateT< T2 > &  js,
const size_t  index,
const Eigen::Vector3< T > &  ref 
)

◆ getScaleDerivative()

template<typename T , typename T2 >
Eigen::Vector3< T > momentum::getScaleDerivative ( const JointStateT< T2 > &  js,
const Eigen::Vector3< T > &  ref 
)

◆ getSkinnedLocatorPosition() [1/2]

template<typename T >
Vector3< T > momentum::getSkinnedLocatorPosition ( const SkinnedLocator locator,
const TransformationList inverseBindPose,
const SkeletonStateT< T > &  state 
)

Computes the world position of a skinned locator using linear blend skinning.

Convenience overload that uses the locator's stored rest position.

Parameters
locatorThe skinned locator containing parent joints, weights, and rest position
inverseBindPoseInverse bind pose transformations for each joint
stateCurrent skeleton state containing joint transformations
Returns
The locator's world position

Definition at line 581 of file linear_skinning.cpp.

References getSkinnedLocatorPosition().

◆ getSkinnedLocatorPosition() [2/2]

template<typename T >
Vector3< T > momentum::getSkinnedLocatorPosition ( const SkinnedLocator locator,
const Vector3< T > &  restPosition,
const TransformationList inverseBindPose,
const SkeletonStateT< T > &  state 
)

Computes the world position of a skinned locator using linear blend skinning.

This function applies linear blend skinning to transform a locator's rest position to its world position based on the current skeleton state. The position is computed by blending the transforms from each parent joint weighted by the corresponding skin weights.

Parameters
locatorThe skinned locator containing parent joints and weights
restPositionThe locator's position in rest pose (bind pose)
inverseBindPoseInverse bind pose transformations for each joint
stateCurrent skeleton state containing joint transformations
Returns
The locator's world position

Definition at line 546 of file linear_skinning.cpp.

References getSkinnedLocatorPosition().

Referenced by getLocatorError(), getSkinnedLocatorPosition(), and getSkinnedLocatorPosition().

◆ getSkinnedLocatorPosition< double >() [1/2]

◆ getSkinnedLocatorPosition< double >() [2/2]

◆ getSkinnedLocatorPosition< float >() [1/2]

◆ getSkinnedLocatorPosition< float >() [2/2]

template Vector3< float > momentum::getSkinnedLocatorPosition< float > ( const SkinnedLocator locator,
const Vector3< float > &  restPosition,
const TransformationList inverseBindPose,
const SkeletonStateT< float > &  state 
)

◆ getTypeSize()

int32_t momentum::getTypeSize ( const fx::gltf::Accessor::Type &  ty)
inline

Definition at line 34 of file accessor_utils.h.

Referenced by copyAccessorBuffer(), and copyAlignedAccessorBuffer().

◆ gradient_jointParams_to_modelParams() [1/2]

template<typename T >
void momentum::gradient_jointParams_to_modelParams ( const T grad_jointParams,
const Eigen::Index  iJointParam,
const ParameterTransform parameterTransform,
Eigen::Ref< Eigen::VectorX< T > >  gradient 
)

◆ gradient_jointParams_to_modelParams() [2/2]

template<typename T >
void momentum::gradient_jointParams_to_modelParams ( const T  grad_jointParams,
const Eigen::Index  iJointParam,
const ParameterTransform parameterTransform,
Eigen::Ref< Eigen::VectorX< T > >  gradient 
)

◆ hessianInverseTimes()

template<typename T >
Eigen::VectorX< T > momentum::hessianInverseTimes ( Eigen::Ref< const Eigen::MatrixX< T > >  jacobian,
Eigen::Ref< const Eigen::VectorX< T > >  v 
)

Definition at line 75 of file fully_differentiable_body_ik.cpp.

References sqr().

◆ intersectFace()

template<typename T >
bool momentum::intersectFace ( const MeshT< T > &  mesh,
const std::vector< Vector3< T > > &  faceNormals,
const int32_t  face0,
const int32_t  face1 
)

test whether two given faces of a mesh intersect with each other

Definition at line 27 of file intersection.cpp.

References momentum::MeshT< T >::faces, and momentum::MeshT< T >::vertices.

Referenced by intersectMesh(), and intersectMeshBruteForce().

◆ intersectFace< double >()

template bool momentum::intersectFace< double > ( const MeshT< double > &  mesh,
const std::vector< Vector3< double > > &  faceNormals,
const int32_t  face0,
const int32_t  face1 
)

◆ intersectFace< float >()

template bool momentum::intersectFace< float > ( const MeshT< float > &  mesh,
const std::vector< Vector3< float > > &  faceNormals,
const int32_t  face0,
const int32_t  face1 
)

◆ intersectMesh()

template<typename T >
std::vector< std::pair< int32_t, int32_t > > momentum::intersectMesh ( const MeshT< T > &  mesh)

test if the mesh self intersects anywhere and return all intersecting face pairs using a bvh tree

Definition at line 119 of file intersection.cpp.

References cross(), momentum::MeshT< T >::faces, intersectFace(), and momentum::MeshT< T >::vertices.

◆ intersectMesh< double >()

template std::vector< std::pair< int32_t, int32_t > > momentum::intersectMesh< double > ( const MeshT< double > &  mesh)

◆ intersectMesh< float >()

template std::vector< std::pair< int32_t, int32_t > > momentum::intersectMesh< float > ( const MeshT< float > &  mesh)

◆ intersectMeshBruteForce()

template<typename T >
std::vector< std::pair< int32_t, int32_t > > momentum::intersectMeshBruteForce ( const MeshT< T > &  mesh)

test if the mesh self intersects anywhere and return all intersecting face pairs using brute force

Definition at line 94 of file intersection.cpp.

References cross(), momentum::MeshT< T >::faces, intersectFace(), and momentum::MeshT< T >::vertices.

◆ intersectMeshBruteForce< double >()

template std::vector< std::pair< int32_t, int32_t > > momentum::intersectMeshBruteForce< double > ( const MeshT< double > &  mesh)

◆ intersectMeshBruteForce< float >()

template std::vector< std::pair< int32_t, int32_t > > momentum::intersectMeshBruteForce< float > ( const MeshT< float > &  mesh)

◆ isApprox()

template<typename T = float>
bool momentum::isApprox ( T  l,
T  r,
T  eps = Eps<T>(1e-4, 1e-6) 
)
noexcept

◆ isGlobalTransformZero()

bool momentum::isGlobalTransformZero ( const Eigen::VectorXf &  dof,
const ParameterSet rigidParams 
)

Check if the global transform is zero by checking if any rigid parameters are non-zero.

This is used to determine whether initialization is needed for pose tracking. If all rigid parameters are zero, we need to solve for an initial rigid transform.

Parameters
dofThe parameter vector to check
rigidParamsParameter set defining which parameters are rigid/global
Returns
True if global transform is zero (needs initialization), false otherwise

Definition at line 468 of file marker_tracker.cpp.

Referenced by trackPosesForFrames().

◆ isInRange() [1/2]

bool momentum::isInRange ( const LimitLinear limit,
float  value 
)

If rangeMin and rangeMax are both 0, the limit applies to all values.

Definition at line 104 of file parameter_limits.cpp.

Referenced by momentum::LimitErrorFunctionT< T >::getError(), momentum::LimitErrorFunctionT< T >::getGradient(), and momentum::LimitErrorFunctionT< T >::getJacobian().

◆ isInRange() [2/2]

bool momentum::isInRange ( const LimitLinearJoint limit,
float  value 
)

If rangeMin and rangeMax are both 0, the limit applies to all values.

Definition at line 114 of file parameter_limits.cpp.

◆ IsNanNoOpt()

bool momentum::IsNanNoOpt ( float  f)
inline

NaN check function that isn't optimized away by fastmath.

Unlike std::isnan(), this implementation is not affected by compiler optimizations when using fast math options

Definition at line 25 of file utility.h.

Referenced by momentum::MeshT< T >::updateNormals().

◆ isRelatedJoint()

bool momentum::isRelatedJoint ( const momentum::Skeleton skeleton,
uint32_t  jointA,
uint32_t  jointB 
)

Check if two joints are related (same joint, parent-child, or child-parent relationship).

Parameters
skeletonThe skeleton containing the joint hierarchy
jointAFirst joint index
jointBSecond joint index
Returns
True if the joints are related (same, or one is the parent of the other)

Definition at line 160 of file tracker_utils.cpp.

References momentum::SkeletonT< T >::joints, and skeleton.

Referenced by closestPointOnMeshMatchingParent().

◆ jacobian_jointParams_to_modelParams() [1/5]

template<typename T >
void momentum::jacobian_jointParams_to_modelParams ( const Eigen::Ref< const Eigen::VectorX< T > > &  jacobian_jointParams,
const Eigen::Index  iJointParam,
const ParameterTransform parameterTransform,
Eigen::Ref< Eigen::MatrixX< T > >  jacobian 
)

◆ jacobian_jointParams_to_modelParams() [2/5]

template<typename T >
void momentum::jacobian_jointParams_to_modelParams ( const Eigen::Ref< const Eigen::VectorX< T > >  jacobian_jointParams,
const Eigen::Index  iJointParam,
const ParameterTransform parameterTransform,
Eigen::Ref< Eigen::MatrixX< T > >  jacobian 
)

◆ jacobian_jointParams_to_modelParams() [3/5]

__vectorcall DRJIT_INLINE void momentum::jacobian_jointParams_to_modelParams ( const FloatP jacobian_jointParams,
const Eigen::Index  iJointParam,
const ParameterTransform parameterTransform_,
Eigen::Ref< Eigen::MatrixX< float > >  jacobian 
)

◆ jacobian_jointParams_to_modelParams() [4/5]

template<typename T >
void momentum::jacobian_jointParams_to_modelParams ( const T jacobian_jointParams,
const Eigen::Index  iJointParam,
const ParameterTransform parameterTransform,
Eigen::Ref< Eigen::MatrixX< T > >  jacobian 
)

◆ jacobian_jointParams_to_modelParams() [5/5]

template<typename T >
void momentum::jacobian_jointParams_to_modelParams ( const T  jacobian_jointParams,
const Eigen::Index  iJointParam,
const ParameterTransform parameterTransform,
Eigen::Ref< Eigen::MatrixX< T > >  jacobian 
)

◆ jointIdentityToModelIdentity()

ModelParameters momentum::jointIdentityToModelIdentity ( const Character c,
const ParameterSet idSet,
const JointParameters jointIdentity 
)

◆ ln2()

template<typename T = float>
constexpr T momentum::ln2 ( )
constexprnoexcept

< log_e 2

Definition at line 31 of file constants.h.

Referenced by momentum::SimdNormalErrorFunction::getGradient().

◆ loadBlendShape() [1/2]

BlendShape momentum::loadBlendShape ( const filesystem::path &  filename,
int  expectedShapes = -1,
int  expectedVertices = -1 
)

Loads a blend shape from a file, including base shape and shape vectors.

Parameters
filenamePath to the blend shape data file
expectedShapesLimits number of shape vectors loaded if > 0, otherwise loads all
expectedVerticesLimits number of vertices loaded if > 0, otherwise loads all
Returns
BlendShape object with loaded data
Note
Only supports local files. For non-local paths, use the stream version.

Definition at line 89 of file blend_shape_io.cpp.

References loadBlendShape().

Referenced by loadBlendShape().

◆ loadBlendShape() [2/2]

BlendShape momentum::loadBlendShape ( std::istream &  data,
int  expectedShapes = -1,
int  expectedVertices = -1 
)

Loads a blend shape from a stream, including base shape and shape vectors.

Parameters
dataInput stream containing blend shape data
expectedShapesLimits number of shape vectors loaded if > 0, otherwise loads all
expectedVerticesLimits number of vertices loaded if > 0, otherwise loads all
Returns
BlendShape object with loaded data

Definition at line 94 of file blend_shape_io.cpp.

◆ loadBlendShapeBase() [1/2]

BlendShapeBase momentum::loadBlendShapeBase ( const filesystem::path &  filename,
int  expectedShapes = -1,
int  expectedVertices = -1 
)

Loads blend shape vectors from a file without base shape.

Parameters
filenamePath to the blend shape base data file
expectedShapesLimits number of shape vectors loaded if > 0, otherwise loads all
expectedVerticesLimits number of vertices loaded if > 0, otherwise loads all
Returns
BlendShapeBase object with loaded shape vectors

Definition at line 66 of file blend_shape_io.cpp.

References loadBlendShapeBase().

Referenced by loadBlendShapeBase().

◆ loadBlendShapeBase() [2/2]

BlendShapeBase momentum::loadBlendShapeBase ( std::istream &  data,
int  expectedShapes = -1,
int  expectedVertices = -1 
)

Loads blend shape vectors from a stream without base shape.

Parameters
dataInput stream containing blend shape base data
expectedShapesLimits number of shape vectors loaded if > 0, otherwise loads all
expectedVerticesLimits number of vertices loaded if > 0, otherwise loads all
Returns
BlendShapeBase object with loaded shape vectors

Definition at line 71 of file blend_shape_io.cpp.

◆ loadC3d()

std::vector< MarkerSequence > momentum::loadC3d ( const std::string &  filename,
UpVector  up = UpVector::Y,
std::span< const std::string >  validMarkerNames = {} 
)

Loads all the subjects from a C3D file into a vector of MarkerSequences.

The function reads the given C3D file and stores the marker data as a MarkerSequence. The unit of the input file will be read from the file and converted to the momentum unit (i.e., cm). The UpVector parameter 'up' is the up-vector convention of the input marker file.

Parameters
[in]filenameThe C3D file to load marker data from.
[in]up(Optional) The up-vector convention of the input marker file (default: UpVector::Y).
Returns
std::vector<MarkerSequence> A vector containing the marker sequences from the C3D file.

Definition at line 73 of file c3d_io.cpp.

References MT_LOGD, MT_LOGE, MT_LOGW_IF, momentum::Marker::name, and toMomentumVector3().

Referenced by loadMarkers().

◆ loadCalibratedModel()

std::tuple< momentum::Character, momentum::ModelParameters > momentum::loadCalibratedModel ( const std::string &  modelFile)

Definition at line 149 of file app_utils.cpp.

References jointIdentityToModelIdentity(), and loadCharacterWithMotion().

◆ loadCharacterFromLegacyJson()

Character momentum::loadCharacterFromLegacyJson ( const std::string &  jsonPath)

Loads a Character from a legacy JSON format that was previously used by older Python libraries (and some other tools).

The legacy JSON format contains:

  • "skeleton": FBX skeleton structure with joints, hierarchy, and transforms
  • "skinnedmodel": Mesh data with skinning weights
  • "collision": Optional collision geometry (tapered capsules)
Parameters
[in]jsonPathPath to the legacy JSON file
Returns
The loaded Character object
Exceptions
std::runtime_errorif the file cannot be loaded or parsed

Definition at line 500 of file legacy_json_io.cpp.

References loadCharacterFromLegacyJsonString(), and MT_THROW_IF.

◆ loadCharacterFromLegacyJsonBuffer()

Character momentum::loadCharacterFromLegacyJsonBuffer ( std::span< const std::byte >  jsonBuffer)

Loads a Character from a legacy JSON buffer.

Parameters
[in]jsonBufferBuffer containing the legacy JSON data
Returns
The loaded Character object
Exceptions
std::runtime_errorif the buffer cannot be parsed

Definition at line 510 of file legacy_json_io.cpp.

References loadCharacterFromLegacyJsonString().

◆ loadCharacterFromLegacyJsonString()

Character momentum::loadCharacterFromLegacyJsonString ( const std::string &  jsonString)

Loads a Character from a legacy JSON string.

Parameters
[in]jsonStringString containing the legacy JSON data
Returns
The loaded Character object
Exceptions
std::runtime_errorif the string cannot be parsed

Definition at line 515 of file legacy_json_io.cpp.

References momentum::ParameterTransformT< float >::empty(), momentum::SkeletonT< T >::joints, kParametersPerJoint, MT_THROW_IF, parameterTransform, and skeleton.

Referenced by loadCharacterFromLegacyJson(), and loadCharacterFromLegacyJsonBuffer().

◆ loadCharacterWithIdentity()

◆ loadCharacterWithMotion() [1/2]

std::tuple< Character, MatrixXf, momentum::JointParameters, float > momentum::loadCharacterWithMotion ( const filesystem::path &  gltfFilename)

Load a glTF character with motion from a file path.

This function loads both the character and motion data from a glTF file. The motion is represented in model parameters and the identity vector is represented as joint parameters. This function assumes the file format is glTF without checking the extension.

Parameters
[in]gltfFilenameThe path to the glTF file.
Returns
A tuple containing the loaded Character object, the motion represented in model parameters, the identity vector represented as joint parameters, and the fps.

Definition at line 1349 of file gltf_io.cpp.

Referenced by loadCalibratedModel(), and loadCharacterWithIdentity().

◆ loadCharacterWithMotion() [2/2]

std::tuple< Character, MatrixXf, momentum::JointParameters, float > momentum::loadCharacterWithMotion ( std::span< const std::byte >  byteSpan)

Load a glTF character from a buffer.

Parameters
[in]byteSpanThe buffer containing the glTF character data.
Returns
A tuple containing the loaded Character object, the motion represented in model parameters, the identity vector represented as joint parameters, and the fps.

Definition at line 1354 of file gltf_io.cpp.

◆ loadCharacterWithMotionModelParameterScales() [1/2]

std::tuple< Character, MatrixXf, momentum::ModelParameters, float > momentum::loadCharacterWithMotionModelParameterScales ( const filesystem::path &  gltfFilename)

Load a glTF character with motion and apply scale parameters to the motion.

This function loads both the character and motion data from a glTF file, applying the character's scale parameters directly to the motion as model parameters. This approach is preferred over the deprecated method of storing scales in an offset vector in the parameter transform. The scale parameters from the identity vector are integrated into the motion data for each frame.

Parameters
[in]gltfFilenameThe path to the glTF file.
Returns
A tuple containing the loaded Character object, the motion represented in model parameters with scales applied, the identity parameters as model parameters, and the fps.

Definition at line 1359 of file gltf_io.cpp.

References loadCharacterWithMotionModelParameterScales(), MT_THROW, and MT_THROW_IF.

Referenced by loadCharacterWithMotionModelParameterScales().

◆ loadCharacterWithMotionModelParameterScales() [2/2]

std::tuple< Character, MatrixXf, momentum::ModelParameters, float > momentum::loadCharacterWithMotionModelParameterScales ( std::span< const std::byte >  byteSpan)

Load a glTF character with motion and apply scale parameters to the motion.

This function loads both the character and motion data from a glTF file, applying the character's scale parameters directly to the motion as model parameters. This approach is preferred over the deprecated method of storing scales in an offset vector in the parameter transform. The scale parameters from the identity vector are integrated into the motion data for each frame.

Parameters
[in]byteSpanThe buffer containing the glTF character data.
Returns
A tuple containing the loaded Character object, the motion represented in model parameters with scales applied, the identity parameters as model parameters, and the fps.

Definition at line 1377 of file gltf_io.cpp.

References momentum::ParameterTransformT< T >::getScalingParameters(), MT_LOGW, MT_THROW_IF, momentum::ParameterTransformT< T >::name, momentum::ParameterTransformT< T >::numAllModelParameters(), momentum::CharacterT< T >::parameterTransform, momentum::ParameterTransformT< T >::simplify(), and momentum::EigenStrongType< Derived, EigenType >::Zero().

◆ loadCharacterWithSkeletonStates() [1/2]

std::tuple< Character, std::vector< SkeletonState >, std::vector< float > > momentum::loadCharacterWithSkeletonStates ( const filesystem::path &  gltfFilename)

Load a glTF character with motion in the form of skeleton states.

This function loads motion data as skeleton states (transform matrices) instead of model parameters. Unlike the other loadCharacterWithMotion functions, this function does not require the file to be saved using momentum's custom glTF extension for model parameters. However, the resulting skeleton states may be harder to work with than model parameters.

Parameters
[in]gltfFilenameThe path to the glTF file.
Returns
A tuple containing the loaded Character object, a vector of skeleton states for each frame, and a vector of timestamps.

Definition at line 1435 of file gltf_io.cpp.

◆ loadCharacterWithSkeletonStates() [2/2]

std::tuple< Character, std::vector< SkeletonState >, std::vector< float > > momentum::loadCharacterWithSkeletonStates ( std::span< const std::byte >  byteSpan)

Load a glTF character with motion in the form of skeleton states.

This function loads motion data as skeleton states (transform matrices) instead of model parameters. Unlike the other loadCharacterWithMotion functions, this function does not require the file to be saved using momentum's custom glTF extension for model parameters. However, the resulting skeleton states may be harder to work with than model parameters.

Parameters
[in]byteSpanThe buffer containing the glTF character data.
Returns
A tuple containing the loaded Character object, a vector of skeleton states for each frame, and a vector of timestamps.

Definition at line 1430 of file gltf_io.cpp.

◆ loadFbxCharacter() [1/2]

Character momentum::loadFbxCharacter ( const filesystem::path &  inputPath,
KeepLocators  keepLocators,
Permissive  permissive,
LoadBlendShapes  loadBlendShapes,
bool  stripNamespaces 
)

Definition at line 826 of file fbx_io.cpp.

References loadOpenFbxCharacter().

◆ loadFbxCharacter() [2/2]

Character momentum::loadFbxCharacter ( std::span< const std::byte >  inputSpan,
KeepLocators  keepLocators,
Permissive  permissive,
LoadBlendShapes  loadBlendShapes,
bool  stripNamespaces 
)

Definition at line 836 of file fbx_io.cpp.

References loadOpenFbxCharacter().

◆ loadFbxCharacterWithMotion() [1/2]

std::tuple< Character, std::vector< MatrixXf >, float > momentum::loadFbxCharacterWithMotion ( const filesystem::path &  inputPath,
KeepLocators  keepLocators,
Permissive  permissive,
LoadBlendShapes  loadBlendShapes,
bool  stripNamespaces 
)

Definition at line 846 of file fbx_io.cpp.

References loadOpenFbxCharacterWithMotion().

◆ loadFbxCharacterWithMotion() [2/2]

std::tuple< Character, std::vector< MatrixXf >, float > momentum::loadFbxCharacterWithMotion ( std::span< const std::byte >  inputSpan,
KeepLocators  keepLocators,
Permissive  permissive,
LoadBlendShapes  loadBlendShapes,
bool  stripNamespaces 
)

Definition at line 856 of file fbx_io.cpp.

References loadOpenFbxCharacterWithMotion().

◆ loadFbxMarkerSequence()

MarkerSequence momentum::loadFbxMarkerSequence ( const filesystem::path &  filename,
bool  stripNamespaces = true 
)

Loads a MarkerSequence from an FBX file.

This function reads motion capture marker data from an FBX file and returns it as a MarkerSequence. The markers must be stored in the FBX scene hierarchy under a "Markers" root node, and each marker node must have the custom property "Momentum_Marker" to be recognized. The Markers root node must have the custom property "Momentum_Markers_Root" to be identified.

Parameters
[in]filenamePath to the FBX file containing marker data.
stripNamespacesRemoves namespace from joints when true. True by default
Returns
A MarkerSequence object containing the marker animation data, including marker positions per frame and fps. Returns an empty sequence if no markers or animations are found.

Definition at line 866 of file fbx_io.cpp.

References loadOpenFbxMarkerSequence().

Referenced by loadMarkers().

◆ loadFullCharacter()

Character momentum::loadFullCharacter ( const std::string &  characterPath,
const std::string &  parametersPath = std::string(),
const std::string &  locatorsPath = std::string(),
LoadBlendShapes  loadBlendShapes = LoadBlendShapes::No 
)

High level function to load a character of any type, with a local path.

Parameters
[in]characterPathThe path to the character file.
[in]parametersPathThe optional path to the file containing additional parameters for the character.
[in]locatorsPathThe optional path to the file containing additional locators for the character.
[in]loadBlendShapesWhether to load blendshapes from the file (default: No).
Returns
The loaded Character object.

Currently, only supports .glb and .fbx. If you want to parse from a non-local path, you may need to parse it using your favorite resource retriever into a buffer and use the buffer version of this function.

Definition at line 93 of file character_io.cpp.

References loadLocators(), loadMomentumModel(), loadParameters(), MT_THROW_IF, and Unknown.

Referenced by loadCharacterWithIdentity().

◆ loadFullCharacterFromBuffer()

Character momentum::loadFullCharacterFromBuffer ( CharacterFormat  format,
std::span< const std::byte >  characterBuffer,
std::span< const std::byte >  paramBuffer = std::span< const std::byte >(),
std::span< const std::byte >  locBuffer = std::span< const std::byte >(),
LoadBlendShapes  loadBlendShapes = LoadBlendShapes::No 
)

Buffer version of loadFullCharacter function, supports .glb and .fbx file formats.

Parameters
[in]formatThe character file format.
[in]characterBufferThe buffer containing the character data.
[in]paramBufferThe optional buffer containing additional parameters for the character.
[in]locBufferThe optional buffer containing additional locators for the character.
[in]loadBlendShapesWhether to load blendshapes from the file (default: No).
Returns
The loaded Character object.

Definition at line 122 of file character_io.cpp.

References loadLocatorsFromBuffer(), loadMomentumModelFromBuffer(), loadParameters(), and MT_THROW_IF.

◆ loadGltfCharacter() [1/3]

Character momentum::loadGltfCharacter ( const filesystem::path &  gltfFilename)

Load a glTF character from a file path.

This function assumes the file format is glTF without checking the extension.

Parameters
[in]gltfFilenameThe path to the glTF file.
Returns
The loaded Character object.

Definition at line 1299 of file gltf_io.cpp.

◆ loadGltfCharacter() [2/3]

Character momentum::loadGltfCharacter ( const fx::gltf::Document &  model)

Load a glTF character from a document.

Parameters
[in]modelThe glTF document to load from.
Returns
The loaded Character object.

Definition at line 1294 of file gltf_io.cpp.

◆ loadGltfCharacter() [3/3]

Character momentum::loadGltfCharacter ( std::span< const std::byte >  byteSpan)

Load a glTF character from a byte buffer.

Parameters
[in]byteSpanThe buffer containing the glTF character data.
Returns
The loaded Character object.

Definition at line 1303 of file gltf_io.cpp.

◆ loadLocators()

LocatorList momentum::loadLocators ( const filesystem::path &  filename,
const Skeleton skeleton,
const ParameterTransform parameterTransform 
)

◆ loadLocatorsFromBuffer()

LocatorList momentum::loadLocatorsFromBuffer ( std::span< const std::byte >  rawData,
const Skeleton skeleton,
const ParameterTransform parameterTransform 
)

◆ loadMarkers()

std::vector< MarkerSequence > momentum::loadMarkers ( const std::string &  filename,
UpVector  up = UpVector::Y,
std::span< const std::string >  validMarkerNames = {} 
)

Loads all actor sequences from a marker file (c3d, trc, glb) and converts the positions to the target coordinate system.

Default target coordinate system is: (Y-up, right-handed, centimeter units).

Parameters
[in]filenameThe marker file to load data from.
[in]up(Optional) The up-vector convention of the input marker file (default: UpVector::Y).
Returns
std::vector<MarkerSequence> A vector of MarkerSequences containing the marker data from the file.

Definition at line 32 of file marker_io.cpp.

References loadC3d(), loadFbxMarkerSequence(), loadMarkerSequence(), loadTrc(), and MT_LOGE.

Referenced by loadMarkersForMainSubject(), and processMarkerFile().

◆ loadMarkerSequence()

MarkerSequence momentum::loadMarkerSequence ( const filesystem::path &  filename)

Load a marker sequence from a glTF file.

This function loads motion capture marker data from a glTF file.

Parameters
[in]filenamePath to the glTF file containing the marker sequence data.
Returns
A MarkerSequence object containing the loaded motion capture marker data.

Definition at line 1481 of file gltf_io.cpp.

References momentum::MarkerSequence::fps, momentum::MarkerSequence::frames, MT_CHECK, and toMomentumVec3f().

Referenced by loadMarkers().

◆ loadMarkersForMainSubject()

std::optional< MarkerSequence > momentum::loadMarkersForMainSubject ( const std::string &  filename,
UpVector  up = UpVector::Y,
std::span< const std::string >  validMarkerNames = {} 
)

Loads the main subject's marker data from a marker file (c3d, trc, glb) and converts the positions to the target coordinate system.

Default target coordinate system is: (Y-up, right-handed, centimeter units). The main subject is determined as the one with the most number of visible markers in the first frame.

Parameters
[in]filenameThe marker file to load data from.
[in]up(Optional) The up-vector convention of the input marker file (default: UpVector::Y).
Returns
std::optional<MarkerSequence> A MarkerSequence containing the main subject's marker data, or an empty optional if no main subject is found.

Definition at line 56 of file marker_io.cpp.

References findMainSubjectIndex(), and loadMarkers().

◆ loadMmo() [1/2]

std::tuple< MatrixXf, VectorXf, std::vector< std::string >, std::vector< std::string > > momentum::loadMmo ( const std::string &  filename)

Load motion data from file.

Parameters
filenameInput file path
Returns
Tuple of (poses, scale, parameter names, joint names)

Definition at line 249 of file mmo_io.cpp.

References kParametersPerJoint, and MT_LOGW.

◆ loadMmo() [2/2]

std::tuple< MatrixXf, VectorXf > momentum::loadMmo ( const std::string &  filename,
const Character character 
)

Load motion data and map to character parameter space.

Parameters
filenameInput file path
characterTarget character for parameter mapping
Returns
Tuple of (mapped poses, mapped scale)

Definition at line 218 of file mmo_io.cpp.

References loadMmo(), and mapMotionToCharacter().

Referenced by loadMmo().

◆ loadModelDefinition() [1/2]

std::tuple< ParameterTransform, ParameterLimits > momentum::loadModelDefinition ( const filesystem::path &  filename,
const Skeleton skeleton 
)

Definition at line 534 of file parameter_transform_io.cpp.

References MT_THROW_IF, and skeleton.

◆ loadModelDefinition() [2/2]

std::tuple< ParameterTransform, ParameterLimits > momentum::loadModelDefinition ( std::span< const std::byte >  rawData,
const Skeleton skeleton 
)

Definition at line 546 of file parameter_transform_io.cpp.

References MT_THROW_IF, and skeleton.

◆ loadMomentumModel()

std::unordered_map< std::string, std::string > momentum::loadMomentumModel ( const filesystem::path &  filename)

Definition at line 258 of file parameter_transform_io.cpp.

References MT_THROW_IF.

Referenced by loadFullCharacter().

◆ loadMomentumModelFromBuffer()

std::unordered_map< std::string, std::string > momentum::loadMomentumModelFromBuffer ( std::span< const std::byte >  buffer)

Definition at line 274 of file parameter_transform_io.cpp.

Referenced by loadFullCharacterFromBuffer().

◆ loadMotion()

std::tuple< MotionParameters, IdentityParameters, float > momentum::loadMotion ( const filesystem::path &  gltfFilename)

Load motion data from a glTF file.

Parameters
[in]gltfFilenameThe path to the glTF file.
Returns
A tuple containing the motion parameters, identity parameters, and fps.

Definition at line 1307 of file gltf_io.cpp.

References MT_THROW.

◆ loadMotionOnCharacter() [1/2]

std::tuple< MatrixXf, JointParameters, float > momentum::loadMotionOnCharacter ( const filesystem::path &  gltfFilename,
const Character character 
)

Load motion from a glTF file and map it to a character.

This function loads motion data from a glTF file and maps it onto the input character by matching joint names and parameter names. This is useful when the motion was saved with a different character but you want to apply it to your character. This function assumes the file format is glTF without checking the extension.

Parameters
[in]gltfFilenameThe path to the glTF motion file.
[in]characterThe Character object to map the motion onto.
Returns
A tuple containing the motion represented in model parameters, the identity vector represented as joint parameters, and the fps. The model parameters and joint parameters are mapped to the input character by name matching.

Definition at line 1439 of file gltf_io.cpp.

◆ loadMotionOnCharacter() [2/2]

std::tuple< MatrixXf, JointParameters, float > momentum::loadMotionOnCharacter ( std::span< const std::byte >  byteSpan,
const Character character 
)

Load motion from a buffer and map it to a character.

This function loads motion data from a buffer and maps it onto the input character by matching joint names and parameter names. This is useful when the motion was saved with a different character but you want to apply it to your character.

Parameters
[in]byteSpanThe buffer containing the glTF motion data.
[in]characterThe Character object to map the motion onto.
Returns
A tuple containing the motion represented in model parameters, the identity vector represented as joint parameters, and the fps. The model parameters and joint parameters are mapped to the input character by name matching.

Definition at line 1445 of file gltf_io.cpp.

◆ loadMotionTimestamps()

std::vector< int64_t > momentum::loadMotionTimestamps ( const filesystem::path &  gltfFilename)

Load per-frame timestamps from a glTF file.

This function loads timestamps that were saved using GltfBuilder::addMotion.

Parameters
[in]gltfFilenameThe path to the glTF file.
Returns
A vector of per-frame timestamps (usually in microseconds).

Definition at line 1322 of file gltf_io.cpp.

References MT_LOGW, and MT_THROW.

◆ loadMppca() [1/3]

std::shared_ptr< const Mppca > momentum::loadMppca ( const std::span< const unsigned char posePriorDataRaw)

Definition at line 18 of file mppca_io.cpp.

References loadMppca().

Referenced by loadMppca(), and loadMppca().

◆ loadMppca() [2/3]

std::shared_ptr< const Mppca > momentum::loadMppca ( const std::string &  name)

Definition at line 29 of file mppca_io.cpp.

References loadMppca(), and MT_THROW_IF.

◆ loadMppca() [3/3]

std::shared_ptr< const Mppca > momentum::loadMppca ( std::istream &  inputStream)

Definition at line 36 of file mppca_io.cpp.

References MT_THROW, and MT_THROW_IF.

◆ loadOpenFbxCharacter() [1/2]

Character momentum::loadOpenFbxCharacter ( const filesystem::path &  path,
KeepLocators  keepLocators,
Permissive  permissive,
LoadBlendShapes  loadBlendShapes,
bool  stripNamespaces 
)

Definition at line 1346 of file openfbx_loader.cpp.

References loadOpenFbxCharacter().

◆ loadOpenFbxCharacter() [2/2]

Character momentum::loadOpenFbxCharacter ( const std::span< const std::byte >  inputData,
KeepLocators  keepLocators,
Permissive  permissive,
LoadBlendShapes  loadBlendShapes,
bool  stripNamespaces 
)

Definition at line 1335 of file openfbx_loader.cpp.

Referenced by loadFbxCharacter(), loadFbxCharacter(), and loadOpenFbxCharacter().

◆ loadOpenFbxCharacterWithMotion() [1/2]

std::tuple< Character, std::vector< MatrixXf >, float > momentum::loadOpenFbxCharacterWithMotion ( const filesystem::path &  inputPath,
KeepLocators  keepLocators,
Permissive  permissive,
LoadBlendShapes  loadBlendShapes,
bool  stripNamespaces 
)

Definition at line 1370 of file openfbx_loader.cpp.

References loadOpenFbxCharacterWithMotion().

◆ loadOpenFbxCharacterWithMotion() [2/2]

std::tuple< Character, std::vector< MatrixXf >, float > momentum::loadOpenFbxCharacterWithMotion ( std::span< const std::byte >  inputData,
KeepLocators  keepLocators,
Permissive  permissive,
LoadBlendShapes  loadBlendShapes,
bool  stripNamespaces 
)

◆ loadOpenFbxMarkerSequence()

MarkerSequence momentum::loadOpenFbxMarkerSequence ( const filesystem::path &  filename,
bool  stripNamespaces 
)

Definition at line 1385 of file openfbx_loader.cpp.

References MT_THROW_IF.

Referenced by loadFbxMarkerSequence().

◆ loadParameters()

◆ loadPoseShape()

PoseShape momentum::loadPoseShape ( const std::string &  filename,
const Character character 
)

Loads pose shape data from a binary file.

Parameters
filenamePath to the pose shape data file
characterCharacter containing skeleton and mesh for validation and joint mapping
Returns
PoseShape with loaded data, or empty PoseShape if file cannot be opened

Definition at line 18 of file pose_shape_io.cpp.

References momentum::PoseShape::baseJoint, momentum::PoseShape::baseRot, momentum::PoseShape::baseShape, momentum::SkeletonT< T >::getJointIdByName(), momentum::PoseShape::jointMap, momentum::SkeletonT< T >::joints, kInvalidIndex, momentum::CharacterT< T >::mesh, MT_CHECK, momentum::PoseShape::shapeVectors, and momentum::CharacterT< T >::skeleton.

◆ loadTrc()

MarkerSequence momentum::loadTrc ( const std::string &  filename,
UpVector  up = UpVector::Y 
)

Loads marker data from a TRC file into a MarkerSequence.

The function reads the given TRC file and stores the marker data as a MarkerSequence. The unit of the input file will be read from the file and converted to the momentum unit (i.e., cm). The UpVector parameter 'up' is the up-vector convention of the input marker file.

Parameters
[in]filenameThe TRC file to load marker data from.
[in]up(Optional) The up-vector convention of the input marker file (default: UpVector::Y).
Returns
MarkerSequence A MarkerSequence containing the marker data from the TRC file.

Definition at line 19 of file trc_io.cpp.

References momentum::MarkerSequence::fps, GetLineCrossPlatform(), MT_THROW_IF, tokenize(), and toMomentumVector3().

Referenced by loadMarkers().

◆ loadUrdfCharacter() [1/4]

template<typename T >
CharacterT< T > momentum::loadUrdfCharacter ( const filesystem::path &  filepath)

Loads a character from a URDF file.

Definition at line 299 of file urdf_io.cpp.

References MT_THROW.

◆ loadUrdfCharacter() [2/4]

template CharacterT< float > momentum::loadUrdfCharacter ( const filesystem::path &  filepath)

◆ loadUrdfCharacter() [3/4]

template<typename T >
CharacterT< T > momentum::loadUrdfCharacter ( std::span< const std::byte >  bytes)

Loads a character from a URDF file using the provided byte data.

Definition at line 324 of file urdf_io.cpp.

References MT_THROW.

◆ loadUrdfCharacter() [4/4]

template CharacterT< float > momentum::loadUrdfCharacter ( std::span< const std::byte >  bytes)

◆ loadUsdCharacter() [1/2]

Character momentum::loadUsdCharacter ( const filesystem::path &  inputPath)

Load a USD character from a local file path.

Parameters
[in]inputPathThe path to the USD character file.
Returns
The loaded Character object.

Definition at line 469 of file usd_io.cpp.

References MT_THROW_IF.

◆ loadUsdCharacter() [2/2]

Character momentum::loadUsdCharacter ( std::span< const std::byte >  inputSpan)

Load a USD character from a buffer.

Parameters
[in]inputSpanThe buffer containing the USD character data.
Returns
The loaded Character object.

Definition at line 479 of file usd_io.cpp.

References MT_THROW_IF.

◆ locatorsToSkinnedLocators()

momentum::Character momentum::locatorsToSkinnedLocators ( const momentum::Character sourceCharacter,
float  maxDistance = 3.0f,
float  minSkinWeight = 0.03f,
bool  verbose = false 
)

Convert locators to skinned locators by finding the closest point on the mesh surface that matches the correct bone index and using the skinned weights from that point.

Does not add parameters for the skinned locators, however, that should be a separate step if you are planning to solve for their locations.

Parameters
sourceCharacterCharacter with locators to convert
maxDistanceMaximum distance to search for the closest point on the mesh surface. If the locator is further than this distance, it will not be converted.
minSkinWeightMinimum skin weight threshold for considering a mesh triangle as belonging to the same bone as the locator.
verboseIf true, print diagnostic messages about locators that could not be converted.

Definition at line 231 of file tracker_utils.cpp.

References averageTriangleSkinWeights(), closestPointOnMeshMatchingParent(), MT_LOGI_IF, MT_LOGT, momentum::SkinnedLocator::name, and momentum::EigenStrongType< Derived, EigenType >::Zero().

◆ logAxes3D()

void momentum::logAxes3D ( const rerun::RecordingStream &  rec,
const std::string &  path,
float  axisLength 
)
inline

Definition at line 85 of file rerun_compat.h.

◆ logBvh()

void momentum::logBvh ( const rerun::RecordingStream &  rec,
const std::string &  streamName,
const CollisionGeometry collisionGeometry,
const SkeletonState skeletonState 
)

Definition at line 291 of file logger.cpp.

References updateAabb().

Referenced by logCollisionGeometry().

◆ logCharacter()

void momentum::logCharacter ( const rerun::RecordingStream &  rec,
const std::string &  charStreamName,
const Character character,
const CharacterState characterState,
const rerun::Color &  color 
)

◆ logCollisionGeometry()

void momentum::logCollisionGeometry ( const rerun::RecordingStream &  rec,
const std::string &  streamName,
const CollisionGeometry collisionGeometry,
const SkeletonState skeletonState 
)

Definition at line 334 of file logger.cpp.

References momentum::SkeletonStateT< T >::jointState, logBvh(), and pi().

Referenced by logCharacter().

◆ logJointParamNames()

void momentum::logJointParamNames ( const rerun::RecordingStream &  rec,
const std::string &  worldPrefix,
const std::string &  posePrefix,
std::span< const std::string >  names 
)

Definition at line 272 of file logger.cpp.

References kJointParameterNames, and makeSeriesLineWithName().

◆ logJointParams()

void momentum::logJointParams ( const rerun::RecordingStream &  rec,
const std::string &  worldPrefix,
const std::string &  posePrefix,
std::span< const std::string >  names,
const Eigen::VectorXf &  params 
)

Definition at line 236 of file logger.cpp.

References kJointParameterNames, kParametersPerJoint, and makeScalar().

◆ logJoints()

void momentum::logJoints ( const rerun::RecordingStream &  rec,
const std::string &  streamName,
const Skeleton skeleton,
const JointStateList jointStates 
)

◆ logLevelMap()

std::map< std::string, LogLevel > momentum::logLevelMap ( )

Definition at line 70 of file log.cpp.

References Debug, Disabled, Error, Info, Trace, and Warning.

◆ logLocators()

void momentum::logLocators ( const rerun::RecordingStream &  rec,
const std::string &  streamName,
const LocatorList locators,
const LocatorState locatorState 
)

Definition at line 131 of file logger.cpp.

References momentum::LocatorState::position.

Referenced by logCharacter().

◆ logMarkerLocatorCorrespondence()

void momentum::logMarkerLocatorCorrespondence ( const rerun::RecordingStream &  rec,
const std::string &  streamName,
const std::map< std::string, size_t > &  locatorLookup,
const LocatorState locatorState,
std::span< const Marker markers,
const float  kPositionErrorThreshold 
)

Definition at line 168 of file logger.cpp.

References momentum::LocatorState::position.

◆ logMarkers()

void momentum::logMarkers ( const rerun::RecordingStream &  rec,
const std::string &  streamName,
std::span< const Marker markers 
)

Definition at line 107 of file logger.cpp.

◆ logMesh()

void momentum::logMesh ( const rerun::RecordingStream &  rec,
const std::string &  streamName,
const Mesh mesh,
std::optional< rerun::Color >  color = std::nullopt 
)
Parameters
[in](Optional)The color to use for the mesh. If not provided, the colors stored in the mesh are used.

Definition at line 49 of file logger.cpp.

References momentum::MeshT< T >::colors, momentum::MeshT< T >::faces, momentum::MeshT< T >::normals, and momentum::MeshT< T >::vertices.

Referenced by logCharacter().

◆ logModelParamNames()

void momentum::logModelParamNames ( const rerun::RecordingStream &  rec,
const std::string &  worldPrefix,
const std::string &  posePrefix,
std::span< const std::string >  names 
)

Definition at line 258 of file logger.cpp.

References makeSeriesLineWithName().

◆ logModelParams()

void momentum::logModelParams ( const rerun::RecordingStream &  rec,
const std::string &  worldPrefix,
const std::string &  posePrefix,
std::span< const std::string >  names,
const Eigen::VectorXf &  params 
)

Definition at line 218 of file logger.cpp.

References makeScalar().

◆ makeAlignedShared()

template<typename T , std::size_t Alignment = alignof(T), class Deleter = AlignedDeleter>
std::shared_ptr< T > momentum::makeAlignedShared ( std::size_t  n,
Deleter  deleter = Deleter() 
)

Creates a std::shared_ptr for aligned memory.

Definition at line 90 of file aligned.h.

◆ makeAlignedUnique()

template<typename T , std::size_t Alignment = alignof(T), class Deleter = AlignedDeleter>
std::unique_ptr< T, Deleter > momentum::makeAlignedUnique ( std::size_t  n,
Deleter  deleter = Deleter() 
)

Creates a std::unique_ptr for aligned memory.

Definition at line 82 of file aligned.h.

◆ makeCharacterDocument()

fx::gltf::Document momentum::makeCharacterDocument ( const Character character,
float  fps = 120.0f,
const MotionParameters motion = {},
const IdentityParameters offsets = {},
std::span< const std::vector< Marker > >  markerSequence = {},
bool  embedResource = true,
const FileSaveOptions options = FileSaveOptions(),
std::span< const int64_t timestamps = {} 
)

Create a glTF document from a character.

This function creates a glTF document containing the character data and optionally motion, identity offsets, and marker sequences.

Parameters
[in]characterThe Character object to save.
[in]fpsFrame rate of the motion in frames per second (default: 120.0f).
[in]motionOptional motion parameters to include in the document.
[in]offsetsOptional identity parameters (joint offsets) to include in the document.
[in]markerSequenceOptional marker sequence data to include in the document.
[in]embedResourceWhether to embed resources in the document (default: true).
[in]optionsOptional file save options for controlling output.
[in]timestampsOptional per-frame timestamps. Size should match motion columns.
Returns
A glTF document containing the character data.

Definition at line 1451 of file gltf_io.cpp.

References momentum::SkeletonT< T >::joints, momentum::CharacterT< T >::mesh, and momentum::CharacterT< T >::skeleton.

Referenced by saveCharacterToBytes(), saveGltfCharacter(), and saveGltfCharacter().

◆ makeScalar()

template<typename T >
auto momentum::makeScalar ( T  value)
inline

Definition at line 32 of file rerun_compat.h.

Referenced by logJointParams(), and logModelParams().

◆ makeSeriesLine()

auto momentum::makeSeriesLine ( )
inline

Definition at line 44 of file rerun_compat.h.

◆ makeSeriesLineWithName()

auto momentum::makeSeriesLineWithName ( const std::string &  name)
inline

Definition at line 53 of file rerun_compat.h.

Referenced by logJointParamNames(), and logModelParamNames().

◆ makeTransform3D()

template<typename... Args>
auto momentum::makeTransform3D ( Args &&...  args)
inline

Definition at line 78 of file rerun_compat.h.

◆ mapIdentityToCharacter()

JointParameters momentum::mapIdentityToCharacter ( const IdentityParameters inputIdentity,
const Character targetCharacter 
)

Maps the input JointParameter vector to a target character by matching joint names.

Mismatched names will be discarded (source) or set to zero (target). For every matched joint, all 7 parameters will be copied over.

Parameters
[in]inputIdentityInput JointParameter vector with joint names.
[in]targetCharacterTarget character that defines its own Joints.
Returns
A vector of joint parameters for the target character.

Definition at line 719 of file character_utility.cpp.

References kInvalidIndex, kParametersPerJoint, MT_CHECK, and MT_LOGW.

◆ mapMotionToCharacter() [1/2]

std::tuple< MatrixXf, VectorXf > momentum::mapMotionToCharacter ( const MatrixXf poses,
const VectorXf offsets,
std::span< const std::string >  parameterNames,
std::span< const std::string >  jointNames,
const Character character 
)

Map motion data from one parameter space to character parameter space.

Parameters
posesSource motion poses
offsetsSource joint offsets
parameterNamesSource parameter names
jointNamesSource joint names
characterTarget character definition
Returns
Tuple of (mapped poses, mapped offsets)

Definition at line 169 of file mmo_io.cpp.

References momentum::SkeletonT< T >::getJointIdByName(), momentum::SkeletonT< T >::joints, kInvalidIndex, kParametersPerJoint, momentum::ParameterTransformT< T >::name, momentum::ParameterTransformT< T >::numAllModelParameters(), momentum::CharacterT< T >::parameterTransform, and momentum::CharacterT< T >::skeleton.

◆ mapMotionToCharacter() [2/2]

MatrixXf momentum::mapMotionToCharacter ( const MotionParameters inputMotion,
const Character targetCharacter 
)

Maps the input ModelParameter motion to a target character by matching model parameter names.

Mismatched names will be discarded (source) or set to zero (target).

Parameters
[in]inputMotionInput ModelParameter motion with names.
[in]targetCharacterTarget character that defines its own ModelParameters.
Returns
A matrix of model parameters for the target character.

Definition at line 692 of file character_utility.cpp.

References kInvalidIndex, MT_CHECK, and MT_LOGW.

Referenced by loadMmo().

◆ mapParameters()

template<typename T >
Eigen::VectorX< T > momentum::mapParameters ( const ModelParametersT< T > &  in,
const std::vector< size_t > &  mp 
)

◆ mapParameterTransformJoints() [1/3]

template ParameterTransformT< double > momentum::mapParameterTransformJoints ( const ParameterTransformT< double > &  paramTransform,
size_t  numTargetJoints,
const std::vector< size_t > &  jointMapping 
)

◆ mapParameterTransformJoints() [2/3]

template ParameterTransformT< float > momentum::mapParameterTransformJoints ( const ParameterTransformT< float > &  paramTransform,
size_t  numTargetJoints,
const std::vector< size_t > &  jointMapping 
)

◆ mapParameterTransformJoints() [3/3]

template<typename T >
ParameterTransformT< T > momentum::mapParameterTransformJoints ( const ParameterTransformT< T > &  parameterTransform,
size_t  numTargetJoints,
const std::vector< size_t > &  jointMapping 
)

Construct a new parameter transform where the joints have been mapped to a new skeleton.

Joints that are mapped to kInvalidIndex will be simply skipped. Note that this does not delete any parameters so it's possible if you remove enough joints to have "orphan" parameters still kicking around; to avoid this consider also applying an appropriate subsetParameterTransform() operation.

Definition at line 230 of file parameter_transform.cpp.

References momentum::ParameterTransformT< T >::blendShapeParameters, momentum::ParameterTransformT< T >::faceExpressionParameters, kInvalidIndex, kParametersPerJoint, momentum::ParameterTransformT< T >::name, momentum::ParameterTransformT< T >::offsets, momentum::ParameterTransformT< T >::parameterSets, parameterTransform, momentum::ParameterTransformT< T >::poseConstraints, momentum::ParameterTransformT< T >::skinnedLocatorParameters, momentum::ParameterTransformT< T >::transform, and triplets.

◆ MOMENTUM_FWD_DECLARE_TEMPLATE_CLASS() [1/2]

momentum::MOMENTUM_FWD_DECLARE_TEMPLATE_CLASS ( DistanceErrorFunction  )

◆ MOMENTUM_FWD_DECLARE_TEMPLATE_CLASS() [2/2]

momentum::MOMENTUM_FWD_DECLARE_TEMPLATE_CLASS ( FullyDifferentiableProjectionErrorFunction  )

◆ MOMENTUM_FWD_DECLARE_TEMPLATE_STRUCT()

momentum::MOMENTUM_FWD_DECLARE_TEMPLATE_STRUCT ( DistanceConstraintData  )

◆ mppcaToJson()

void momentum::mppcaToJson ( const Character character,
nlohmann::json &  j 
)

◆ nan()

template<typename T = float>
constexpr T momentum::nan ( )
constexprnoexcept

Definition at line 16 of file constants.h.

◆ normal() [1/4]

◆ normal() [2/4]

template<typename DynamicMatrix >
DynamicMatrix momentum::normal ( Eigen::Index  rows,
Eigen::Index  cols,
typename DynamicMatrix::Scalar  mean,
typename DynamicMatrix::Scalar  sigma 
)

Generates a random dynamic size matrix from the Gaussian distribution, using the global random number generator Random.

Definition at line 395 of file random-inl.h.

References momentum::Random< Generator_ >::GetSingleton().

◆ normal() [3/4]

template<typename DynamicVector >
DynamicVector momentum::normal ( Eigen::Index  size,
typename DynamicVector::Scalar  mean,
typename DynamicVector::Scalar  sigma 
)

Generates a random dynamic size vector from the Gaussian distribution, using the global random number generator Random.

Definition at line 386 of file random-inl.h.

References momentum::Random< Generator_ >::GetSingleton().

◆ normal() [4/4]

template<typename FixedSizeT >
FixedSizeT momentum::normal ( typename FixedSizeT::Scalar  mean,
typename FixedSizeT::Scalar  sigma 
)

Generates a random fixed size vector/matrix from the Gaussian distribution, using the global random number generator Random.

Definition at line 380 of file random-inl.h.

References momentum::Random< Generator_ >::GetSingleton().

◆ operator!=()

template<class T , class U , std::size_t Alignment>
bool momentum::operator!= ( const AlignedAllocator< T, Alignment > &  ,
const AlignedAllocator< U, Alignment > &   
)

Checks if storage allocated from lhs cannot be deallocated from rhs, and vice versa.

This always returns false for stateless allocators.

Definition at line 149 of file aligned.h.

◆ operator*() [1/4]

template<typename S , typename Derived >
Vector3P< S > momentum::operator* ( const Eigen::MatrixBase< Derived > &  xf,
const Vector3P< S > &  vec 
)

Calculates multiplication of 3x3 matrix and each 3x1 vector in packet.

Template Parameters
DerivedA derived class of Eigen::MatrixBase, which should be compatible with Eigen::Matrix3f.
Parameters
[in]xfA 3x3 matrix.
[in]vecA 3-vector of packets.

Definition at line 200 of file simd.h.

References dot().

◆ operator*() [2/4]

template<typename S >
Vector3P< S > momentum::operator* ( const Eigen::Quaternion< S > &  q,
const Vector3P< S > &  vec 
)

Calculates multiplication of quaternion and each 3x1 vector in packet.

Parameters
[in]qA quaternion.
[in]vecA 3-vector of packets.

Definition at line 189 of file simd.h.

Referenced by momentum::SimdPlaneErrorFunction::getError(), momentum::SimdNormalErrorFunction::getError(), and momentum::SimdNormalErrorFunction::getGradient().

◆ operator*() [3/4]

template<typename S >
Vector3P< S > momentum::operator* ( const Eigen::Transform< S, 3, Eigen::Affine > &  xf,
const Vector3P< S > &  vec 
)

Calculates affine transformation on each 3x1 vector in packet.

Parameters
[in]xfAn affine transformation matrix.
[in]vecA 3-vector of packets.

Definition at line 210 of file simd.h.

References operator+().

◆ operator*() [4/4]

template<typename S >
Vector3P< S > momentum::operator* ( const TransformT< S > &  xf,
const Vector3P< S > &  vec 
)

Calculates transformation on each 3x1 vector in packet using momentum::Transform.

Parameters
[in]xfA momentum transform.
[in]vecA 3-vector of packets.

Definition at line 219 of file simd.h.

References operator+().

◆ operator+() [1/2]

template<typename S , typename Derived >
Vector3P< S > momentum::operator+ ( const Eigen::MatrixBase< Derived > &  v1,
const Vector3P< S > &  v2 
)

Calculates summation of Eigen::Vector3f and Vector3P.

Template Parameters
DerivedA derived class of Eigen::MatrixBase, which should be compatible with Eigen::Vector3f.
Parameters
[in]v1A 3D vector of Eigen.
[in]v2A 3-vector of packets.

Definition at line 147 of file simd.h.

Referenced by operator*(), and operator*().

◆ operator+() [2/2]

template<typename S , typename Derived >
Vector3P< S > momentum::operator+ ( const Vector3P< S > &  v1,
const Eigen::MatrixBase< Derived > &  v2 
)

Calculates summation of Vector3P and Eigen::Vector3f.

Template Parameters
DerivedA derived class of Eigen::MatrixBase, which should be compatible with Eigen::Vector3f.
Parameters
[in]v1A 3-vector of packets.
[in]v2A 3D vector of Eigen.

Definition at line 158 of file simd.h.

◆ operator-() [1/2]

template<typename S , typename Derived >
Vector3P< S > momentum::operator- ( const Eigen::MatrixBase< Derived > &  v1,
const Vector3P< S > &  v2 
)

Calculates subtraction of Eigen::Vector3f and Vector3P.

Template Parameters
DerivedA derived class of Eigen::MatrixBase, which should be compatible with Eigen::Vector3f.
Parameters
[in]v1A 3D vector of Eigen.
[in]v2A 3-vector of packets.

Definition at line 169 of file simd.h.

Referenced by momentum::SimdNormalErrorFunction::getGradient().

◆ operator-() [2/2]

template<typename S , typename Derived >
Vector3P< S > momentum::operator- ( const Vector3P< S > &  v1,
const Eigen::MatrixBase< Derived > &  v2 
)

Calculates subtraction of Vector3P and Eigen::Vector3f.

Template Parameters
DerivedA derived class of Eigen::MatrixBase, which should be compatible with Eigen::Vector3f.
Parameters
[in]v1A 3-vector of packets.
[in]v2A 3D vector of Eigen.

Definition at line 180 of file simd.h.

◆ operator==()

template<class T , class U , std::size_t Alignment>
bool momentum::operator== ( const AlignedAllocator< T, Alignment > &  ,
const AlignedAllocator< U, Alignment > &   
)

Checks if storage allocated from lhs can be deallocated from rhs, and vice versa.

This always returns true for stateless allocators.

Definition at line 139 of file aligned.h.

◆ overlaps()

template<typename T >
bool momentum::overlaps ( const Vector3< T > &  originA,
const Vector3< T > &  directionA,
const Vector2< T > &  radiiA,
T  deltaA,
const Vector3< T > &  originB,
const Vector3< T > &  directionB,
const Vector2< T > &  radiiB,
T  deltaB,
T outDistance,
Vector2< T > &  outClosestPoints,
T outOverlap 
)

Determines if two tapered capsules overlap.

Parameters
originAOrigin of the first capsule
directionADirection vector of the first capsule
radiiARadii at the endpoints of the first capsule
deltaADifference between radii of the first capsule
originBOrigin of the second capsule
directionBDirection vector of the second capsule
radiiBRadii at the endpoints of the second capsule
deltaBDifference between radii of the second capsule
outDistanceOutput parameter for the distance between the closest points (normalized). No modification on return false.
outOverlapOutput parameter for the overlap amount (positive if overlapping)
Returns
True if the capsules overlap, false otherwise

Definition at line 67 of file collision_geometry_state.h.

Referenced by momentum::CollisionErrorFunctionT< T >::getCollisionPairs(), momentum::CollisionErrorFunctionT< T >::getError(), momentum::CollisionErrorFunctionStatelessT< T >::getError(), momentum::CollisionErrorFunctionT< T >::getGradient(), momentum::CollisionErrorFunctionStatelessT< T >::getGradient(), momentum::CollisionErrorFunctionT< T >::getJacobian(), momentum::CollisionErrorFunctionStatelessT< T >::getJacobian(), momentum::CollisionErrorFunctionT< T >::updateCollisionPairs(), momentum::CollisionErrorFunctionStatelessT< T >::updateCollisionPairs(), and momentum::SimdCollisionErrorFunctionT< T >::updateCollisionPairs().

◆ padToSimdAlignment()

constexpr size_t momentum::padToSimdAlignment ( size_t  size)
constexpr

Pads a row count to be a multiple of kJacobianRowAlignment for SIMD alignment.

This is used when allocating Jacobian matrices to ensure proper alignment for SIMD operations.

Parameters
[in]sizeThe original row count.
Returns
The padded row count, rounded up to the nearest multiple of 8.

Definition at line 27 of file solver_function.h.

References kJacobianRowAlignment.

Referenced by momentum::MultiposeSolverT< T >::doIteration(), momentum::GaussNewtonSolverQRT< T >::doIteration(), momentum::TrustRegionQRT< T >::doIteration(), momentum::SolverFunctionT< T >::getJacobian(), and momentum::SolverFunctionT< T >::getJtJR().

◆ parameterLimitsFromJson()

◆ parameterLimitsToJson()

◆ parameterSetsFromJson()

ParameterSets momentum::parameterSetsFromJson ( const Character character,
const nlohmann::json &  j 
)

◆ parameterSetsToJson()

void momentum::parameterSetsToJson ( const Character character,
nlohmann::json &  j 
)

◆ parameterTransformFromJson()

◆ parameterTransformToJson()

◆ parseParameterLimits() [1/2]

◆ parseParameterLimits() [2/2]

ParameterLimits momentum::parseParameterLimits ( const std::string &  data,
const Skeleton skeleton,
const ParameterTransform parameterTransform,
size_t  lineOffset 
)

◆ parseParameterSets() [1/3]

ParameterSets momentum::parseParameterSets ( const io_detail::SectionContent content,
const ParameterTransform pt 
)

◆ parseParameterSets() [2/3]

ParameterSets momentum::parseParameterSets ( const SectionContent &  content,
const ParameterTransform pt 
)

Definition at line 392 of file parameter_transform_io.cpp.

References kInvalidIndex, MT_LOGW, MT_THROW_IF, tokenize(), and trim().

Referenced by loadParameters(), and parseParameterSets().

◆ parseParameterSets() [3/3]

ParameterSets momentum::parseParameterSets ( const std::string &  data,
const ParameterTransform pt,
size_t  lineOffset 
)

Definition at line 452 of file parameter_transform_io.cpp.

References parseParameterSets().

◆ parseParameterTransform() [1/3]

ParameterTransform momentum::parseParameterTransform ( const io_detail::SectionContent content,
const Skeleton skeleton 
)

◆ parseParameterTransform() [2/3]

◆ parseParameterTransform() [3/3]

ParameterTransform momentum::parseParameterTransform ( const std::string &  data,
const Skeleton skeleton,
size_t  lineOffset 
)

Definition at line 383 of file parameter_transform_io.cpp.

References parseParameterTransform(), and skeleton.

◆ parsePoseConstraints() [1/3]

PoseConstraints momentum::parsePoseConstraints ( const io_detail::SectionContent content,
const ParameterTransform pt 
)

◆ parsePoseConstraints() [2/3]

PoseConstraints momentum::parsePoseConstraints ( const SectionContent &  content,
const ParameterTransform pt 
)

Definition at line 461 of file parameter_transform_io.cpp.

References kInvalidIndex, MT_LOGW, MT_THROW_IF, tokenize(), and trim().

Referenced by loadParameters(), and parsePoseConstraints().

◆ parsePoseConstraints() [3/3]

PoseConstraints momentum::parsePoseConstraints ( const std::string &  data,
const ParameterTransform pt,
size_t  lineOffset 
)

Definition at line 526 of file parameter_transform_io.cpp.

References parsePoseConstraints().

◆ pi()

◆ poseConstraintsFromJson()

PoseConstraints momentum::poseConstraintsFromJson ( const Character character,
const nlohmann::json &  j 
)

◆ poseConstraintsToJson()

void momentum::poseConstraintsToJson ( const Character character,
nlohmann::json &  j 
)

◆ processMarkerFile()

void momentum::processMarkerFile ( const std::string &  inputMarkerFile,
const std::string &  outputFile,
const TrackingConfig trackingConfig,
const CalibrationConfig calibrationConfig,
const ModelOptions modelOptions,
bool  calibrate,
size_t  firstFrame = 0,
size_t  maxFrames = 0 
)

Runs marker tracking on an input marker file (e.g.

c3d) and writes the output motion (e.g. glb) to outputFile

Definition at line 68 of file process_markers.cpp.

References findMainSubjectIndex(), loadCharacterWithIdentity(), loadMarkers(), MT_LOGE, MT_LOGI, processMarkers(), saveMotion(), and Y.

◆ processMarkers()

Eigen::MatrixXf momentum::processMarkers ( momentum::Character character,
momentum::ModelParameters identity,
const std::vector< std::vector< momentum::Marker > > &  markerData,
const TrackingConfig trackingConfig,
const CalibrationConfig calibrationConfig,
bool  calibrate = true,
size_t  firstFrame = 0,
size_t  maxFrames = 0 
)

Processes marker data for a character model.

It can calibrate the model and locators based on the calibrationConfig, and track the motion of the markers.

Parameters
[in,out]characterThe input character definition with locators. It also holds the output locators if locators are to be calibrated from the calibrationConfig.
[in,out]identityThe input identity used for tracking. It also holds the solved identify if identity is to be calibrated from the calibrationConfig.
[in]markerDataThe per-frame position targets to be tracked.
[in]trackingConfigThe config for per-frame tracking after the correct identity and locators are solved for (or from input).
[in]calibrationConfigThe config for running calibration if calibrate is set to true.
[in]calibrateTrue to run calibration according to calibrationConfig.
[in]firstFrameThe first frame to start solving. We pass in the first frame instead of triming markerData to avoid data copy.
[in]maxFramesThe maximum number of frames to process starting from firstFrame.
Returns
The final motion matrix after tracking.

Definition at line 23 of file process_markers.cpp.

References calibrateLocators(), calibrateModel(), getLocatorError(), MT_CHECK, MT_LOGI, MT_THROW_IF, and trackPosesPerframe().

Referenced by processMarkerFile().

◆ pseudoInverse() [1/6]

template MatrixX< double > momentum::pseudoInverse ( const MatrixX< double > &  mat)

◆ pseudoInverse() [2/6]

template MatrixX< float > momentum::pseudoInverse ( const MatrixX< float > &  mat)

◆ pseudoInverse() [3/6]

template<typename T >
MatrixX< T > momentum::pseudoInverse ( const MatrixX< T > &  mat)

Calculates the pseudo-inverse of a matrix.

Uses singular value decomposition (SVD) to compute the Moore-Penrose pseudo-inverse

Template Parameters
TThe scalar type
Parameters
matInput matrix
Returns
The pseudo-inverse of the input matrix

Definition at line 414 of file utility.cpp.

Referenced by pseudoInverse().

◆ pseudoInverse() [4/6]

template MatrixX< double > momentum::pseudoInverse ( const SparseMatrix< double > &  mat)

◆ pseudoInverse() [5/6]

template MatrixX< float > momentum::pseudoInverse ( const SparseMatrix< float > &  mat)

◆ pseudoInverse() [6/6]

template<typename T >
MatrixX< T > momentum::pseudoInverse ( const SparseMatrix< T > &  mat)

Calculates the pseudo-inverse of a sparse matrix.

Converts the sparse matrix to a dense matrix before computing the pseudo-inverse

Template Parameters
TThe scalar type
Parameters
matInput sparse matrix
Returns
The pseudo-inverse as a dense matrix

Definition at line 429 of file utility.cpp.

References pseudoInverse().

◆ quaternionAverage()

Quaternionf momentum::quaternionAverage ( std::span< const Quaternionf q,
std::span< const float w = std::vector< float >() 
)

Computes the weighted average of multiple quaternions.

Uses the method described in Markley et al. "Averaging Quaternions"

Parameters
qArray of quaternions to average
wOptional weights for each quaternion (defaults to equal weights)
Returns
The average quaternion

Definition at line 397 of file utility.cpp.

◆ quaternionExpMap() [1/3]

template Quaternion< double > momentum::quaternionExpMap ( const Vector3< double > &  v)

◆ quaternionExpMap() [2/3]

template Quaternion< float > momentum::quaternionExpMap ( const Vector3< float > &  v)

◆ quaternionExpMap() [3/3]

template<typename T >
Quaternion< T > momentum::quaternionExpMap ( const Vector3< T > &  v)

Computes the exponential map from a rotation vector (axis-angle in R^3) to a quaternion.

The exponential map takes a 3D rotation vector (where the direction is the rotation axis and the magnitude is the rotation angle in radians) and returns the corresponding unit quaternion. This is numerically robust for small angles using Taylor series expansion.

Reference: "Practical Parameterization of Rotations Using the Exponential Map" by F. Sebastian Grassia, Journal of Graphics Tools, 1998.

Template Parameters
TThe scalar type
Parameters
vThe rotation vector (axis-angle representation)
Returns
The corresponding unit quaternion

Definition at line 32 of file utility.cpp.

◆ quaternionLogMap() [1/3]

template Vector3< double > momentum::quaternionLogMap ( const Quaternion< double > &  q)

◆ quaternionLogMap() [2/3]

template Vector3< float > momentum::quaternionLogMap ( const Quaternion< float > &  q)

◆ quaternionLogMap() [3/3]

template<typename T >
Vector3< T > momentum::quaternionLogMap ( const Quaternion< T > &  q)

Computes the logarithmic map from a quaternion to a rotation vector (axis-angle in R^3).

The logarithmic map takes a unit quaternion and returns the corresponding 3D rotation vector (where the direction is the rotation axis and the magnitude is the rotation angle in radians). This is numerically robust for small angles using Taylor series expansion. For quaternions close to -I (180 degree rotation), a consistent branch is chosen.

Reference: "Practical Parameterization of Rotations Using the Exponential Map" by F. Sebastian Grassia, Journal of Graphics Tools, 1998.

Template Parameters
TThe scalar type
Parameters
qThe input quaternion (should be normalized)
Returns
The corresponding rotation vector (axis-angle representation)

Definition at line 71 of file utility.cpp.

Referenced by momentum::StateErrorFunctionT< T >::getError(), momentum::StateSequenceErrorFunctionT< T >::getError(), momentum::StateErrorFunctionT< T >::getGradient(), momentum::StateSequenceErrorFunctionT< T >::getGradient(), momentum::StateErrorFunctionT< T >::getJacobian(), and momentum::StateSequenceErrorFunctionT< T >::getJacobian().

◆ quaternionLogMapDerivative() [1/3]

template Eigen::Matrix< double, 3, 4 > momentum::quaternionLogMapDerivative ( const Quaternion< double > &  q)

◆ quaternionLogMapDerivative() [2/3]

template Eigen::Matrix< float, 3, 4 > momentum::quaternionLogMapDerivative ( const Quaternion< float > &  q)

◆ quaternionLogMapDerivative() [3/3]

template<typename T >
Eigen::Matrix< T, 3, 4 > momentum::quaternionLogMapDerivative ( const Quaternion< T > &  q)

Computes the derivative of the logmap with respect to quaternion components.

Computes the derivative of the logarithmic map with respect to quaternion components.

Given a quaternion q with coeffs [x, y, z, w], computes the Jacobian matrix J where: J(i,j) = d(log(q)[i]) / dq.coeffs()[j] where log(q) is the 3D rotation vector and q.coeffs() = [x, y, z, w].

Reference: "Practical Parameterization of Rotations Using the Exponential Map" by F. Sebastian Grassia, Journal of Graphics Tools, 1998. https://www.cs.cmu.edu/~spiff/moedit99/expmap.pdf

Template Parameters
TThe scalar type
Parameters
qThe input quaternion (should be normalized)
Returns
3x4 Jacobian matrix where column j is the gradient w.r.t. q.coeffs()[j] i.e., columns are ordered as [d/dx, d/dy, d/dz, d/dw]

Given a quaternion q with coeffs [x, y, z, w], computes the Jacobian matrix J where: J(i,j) = d(log(q)[i]) / dq.coeffs()[j] where log(q) is the 3D rotation vector and q.coeffs() = [x, y, z, w] (Eigen's convention).

This is the fundamental building block for computing derivatives of functions involving logmap through the chain rule.

Reference: "Practical Parameterization of Rotations Using the Exponential Map" by F. Sebastian Grassia, Journal of Graphics Tools, 1998.

Template Parameters
TThe scalar type
Parameters
qThe input quaternion (should be normalized)
Returns
3x4 Jacobian matrix where column j is the gradient w.r.t. q.coeffs()[j], i.e., columns are ordered as [d/dx, d/dy, d/dz, d/dw]

Definition at line 127 of file utility.cpp.

Referenced by momentum::StateErrorFunctionT< T >::getGradient(), momentum::StateSequenceErrorFunctionT< T >::getGradient(), momentum::StateErrorFunctionT< T >::getJacobian(), and momentum::StateSequenceErrorFunctionT< T >::getJacobian().

◆ quaternionToEuler() [1/3]

template<typename T >
Vector3< T > momentum::quaternionToEuler ( const Quaternion< T > &  q)

Converts a quaternion to Euler angles using the Extrinsic XYZ convention.

The returned angles [x, y, z] are such that applying Extrinsic rotations RotX(x) then RotY(y) then RotZ(z) (i.e., about fixed world axes) reproduces the input quaternion's rotation. Empirically verified by tests.

Note: This matches the convention used in skeleton_state (skel_state): Extrinsic XYZ.

Template Parameters
TThe scalar type
Parameters
qInput quaternion
Returns
Vector of Euler angles [x, y, z]

Definition at line 387 of file utility.cpp.

References sqr().

◆ quaternionToEuler() [2/3]

template Vector3d momentum::quaternionToEuler ( const Quaterniond q)

◆ quaternionToEuler() [3/3]

template Vector3f momentum::quaternionToEuler ( const Quaternionf q)

◆ redirectLogsToRerun()

bool momentum::redirectLogsToRerun ( const rerun::RecordingStream &  rec)

Redirects logs from the XR_LOG framework to the Rerun logger.

This function registers a custom log sink for the XR_LOG framework, redirecting its log messages to the Rerun logger. The redirection is only performed once, and subsequent calls to this function have no effect.

Parameters
[in]recThe recording stream to which to write the logs. You should make sure the lifetime of this is longer than the loggings from momentum libraries.
Returns
Returns true if the redirection is successful or has already been done.

Definition at line 72 of file logging_redirect.cpp.

References MT_LOGW.

◆ reduceMeshByFaces()

template<typename T >
CharacterT< T > momentum::reduceMeshByFaces ( const CharacterT< T > &  character,
const std::vector< bool > &  activeFaces 
)

Reduces the mesh to only include the specified faces and associated vertices.

Parameters
[in]characterCharacter to be reduced
[in]activeFacesBoolean vector indicating which faces to keep
Returns
A new character with mesh reduced to the specified faces

Definition at line 1114 of file character_utility.cpp.

References facesToVertices(), momentum::CharacterT< T >::mesh, and MT_CHECK.

◆ reduceMeshByFaces< double >()

template CharacterT< double > momentum::reduceMeshByFaces< double > ( const CharacterT< double > &  character,
const std::vector< bool > &  activeFaces 
)

◆ reduceMeshByFaces< float >()

template CharacterT< float > momentum::reduceMeshByFaces< float > ( const CharacterT< float > &  character,
const std::vector< bool > &  activeFaces 
)

◆ reduceMeshByVertices()

template<typename T >
CharacterT< T > momentum::reduceMeshByVertices ( const CharacterT< T > &  character,
const std::vector< bool > &  activeVertices 
)

Reduces the mesh to only include the specified vertices and associated faces.

Parameters
[in]characterCharacter to be reduced
[in]activeVerticesBoolean vector indicating which vertices to keep
Returns
A new character with mesh reduced to the specified vertices

Definition at line 1097 of file character_utility.cpp.

References momentum::CharacterT< T >::mesh, MT_CHECK, and verticesToFaces().

◆ reduceMeshByVertices< double >()

template CharacterT< double > momentum::reduceMeshByVertices< double > ( const CharacterT< double > &  character,
const std::vector< bool > &  activeVertices 
)

◆ reduceMeshByVertices< float >()

template CharacterT< float > momentum::reduceMeshByVertices< float > ( const CharacterT< float > &  character,
const std::vector< bool > &  activeVertices 
)

◆ refineMotion() [1/2]

Eigen::MatrixXf momentum::refineMotion ( std::span< const std::vector< momentum::Marker > >  markerData,
const Eigen::MatrixXf &  motion,
const RefineConfig config,
momentum::Character character 
)

◆ refineMotion() [2/2]

MatrixXf momentum::refineMotion ( std::span< const std::vector< momentum::Marker > >  markerData,
const MatrixXf motion,
const RefineConfig config,
momentum::Character character 
)

Refine existing motion by smoothing and optionally recalibrating identity/locators.

This is a post-processing function that takes an already tracked motion and improves it by applying temporal smoothness constraints, and optionally recalibrating character identity or locator positions. It uses the sequence solver to enforce temporal coherence across frames.

Parameters
markerDataMarker observations for each frame
motionInitial motion to refine (parameters x frames)
configRefinement configuration settings
characterCharacter model (may be modified if calibration is enabled)
Returns
Refined motion parameters matrix with improved temporal consistency

Definition at line 1159 of file marker_tracker.cpp.

References createLocatorCharacter(), extractIdAndLocatorsFromParams(), momentum::ParameterTransformT< T >::getScalingParameters(), momentum::CharacterT< T >::locators, MT_CHECK, momentum::ParameterTransformT< T >::numAllModelParameters(), momentum::ParameterTransformT< T >::parameterSets, momentum::CharacterT< T >::parameterTransform, momentum::CharacterT< T >::skinnedLocators, and trackSequence().

◆ removeIdentity()

void momentum::removeIdentity ( const ParameterSet idSet,
const ModelParameters identity,
Eigen::MatrixXf &  motionWithId 
)

Definition at line 669 of file tracker_utils.cpp.

References momentum::EigenStrongType< Derived, EigenType >::v.

Referenced by saveMotion().

◆ removeJoints()

Character momentum::removeJoints ( const Character character,
std::span< const size_t jointsToRemove 
)

Removes the specified joints and any joints parented beneath them from the character.

Currently, it is necessary to remove child joints to prevent dangling joints. Mesh points skinned to the removed joints are re-skinned to their parent joint in the hierarchy.

Parameters
[in]characterThe character from which joints will be removed.
[in]jointsToRemoveA vector of joint indices to be removed.
Returns
A new Character object that is identical to the original except for the removal of specified joints.

Definition at line 601 of file character_utility.cpp.

References momentum::CharacterT< T >::blendShape, momentum::CharacterT< T >::collision, momentum::ParameterTransformT< float >::empty(), momentum::SkeletonT< T >::joints, kInvalidIndex, kParametersPerJoint, momentum::CharacterT< T >::locators, momentum::CharacterT< T >::mesh, MT_THROW_IF, momentum::CharacterT< T >::parameterLimits, momentum::CharacterT< T >::parameterTransform, momentum::CharacterT< T >::poseShapes, momentum::CharacterT< T >::skeleton, and momentum::CharacterT< T >::skinWeights.

◆ replaceSkeletonHierarchy()

Character momentum::replaceSkeletonHierarchy ( const Character srcCharacter,
const Character tgtCharacter,
const std::string &  srcRootJoint,
const std::string &  tgtRootJoint 
)

Replaces the part of target_character's skeleton rooted at target_root with the part of source_character's skeleton rooted at source_root.

This function is typically used to swap one character's hand skeleton with another, for example.

Parameters
[in]srcCharacterThe source character whose skeleton will be copied.
[in]tgtCharacterThe target character whose skeleton will be replaced.
[in]srcRootJointRoot of the source skeleton hierarchy to be copied.
[in]tgtRootJointRoot of the target skeleton hierarchy to be replaced.
Returns
A new Character that is identical to tgtCharacter except that the skeleton under tgtRootJoint has been replaced by the part of srcCharacter's skeleton rooted at srcRootJoint.

Definition at line 440 of file character_utility.cpp.

References momentum::SkeletonT< T >::joints, kInvalidIndex, kParametersPerJoint, MT_CHECK, MT_LOGW_IF, MT_THROW_IF, momentum::ParameterTransformT< T >::offsets, and skeleton.

◆ rotationMatrixToEuler() [1/3]

template Vector3< double > momentum::rotationMatrixToEuler ( const Matrix3< double > &  m,
int  axis0,
int  axis1,
int  axis2,
EulerConvention  convention 
)

◆ rotationMatrixToEuler() [2/3]

template Vector3< float > momentum::rotationMatrixToEuler ( const Matrix3< float > &  m,
int  axis0,
int  axis1,
int  axis2,
EulerConvention  convention 
)

◆ rotationMatrixToEuler() [3/3]

template<typename T >
Vector3< T > momentum::rotationMatrixToEuler ( const Matrix3< T > &  m,
int  axis0,
int  axis1,
int  axis2,
EulerConvention  convention = EulerConvention::Intrinsic 
)

Converts rotation matrix to Euler angles.

Template Parameters
TThe scalar type.
Parameters
[in]mThe rotation matrix to convert.
[in]axis0The index of the first rotation's axis, one of {0, 1, 2}.
[in]axis1The index of the second rotation's axis, one of {0, 1, 2}.
[in]axis2The index of the third rotation's axis, one of {0, 1, 2}.
[in]conventionThe Euler angles convention.

Definition at line 194 of file utility.cpp.

References Extrinsic, Intrinsic, and rotationMatrixToEuler().

Referenced by rotationMatrixToEuler().

◆ rotationMatrixToEulerXYZ() [1/3]

template Vector3< double > momentum::rotationMatrixToEulerXYZ ( const Matrix3< double > &  m,
EulerConvention  convention 
)

◆ rotationMatrixToEulerXYZ() [2/3]

template Vector3< float > momentum::rotationMatrixToEulerXYZ ( const Matrix3< float > &  m,
EulerConvention  convention 
)

◆ rotationMatrixToEulerXYZ() [3/3]

template<typename T >
Vector3< T > momentum::rotationMatrixToEulerXYZ ( const Matrix3< T > &  m,
EulerConvention  convention 
)

An optimized version of rotationMatrixToEuler(m, 0, 1, 2, convention) or rotationMatrixToEuler(m, 2, 1, 0, convention).reverse().

Definition at line 208 of file utility.cpp.

References Extrinsic, Intrinsic, and rotationMatrixToEulerZYX().

Referenced by rotationMatrixToEulerZYX(), and writeParameterLimits().

◆ rotationMatrixToEulerZYX() [1/3]

template Vector3< double > momentum::rotationMatrixToEulerZYX ( const Matrix3< double > &  m,
EulerConvention  convention 
)

◆ rotationMatrixToEulerZYX() [2/3]

template Vector3< float > momentum::rotationMatrixToEulerZYX ( const Matrix3< float > &  m,
EulerConvention  convention 
)

◆ rotationMatrixToEulerZYX() [3/3]

template<typename T >
Vector3< T > momentum::rotationMatrixToEulerZYX ( const Matrix3< T > &  m,
EulerConvention  convention 
)

An optimized version of rotationMatrixToEuler(m, 2, 1, 0, convention) or rotationMatrixToEuler(m, 0, 1, 2, convention).reverse().

Definition at line 249 of file utility.cpp.

References Extrinsic, Intrinsic, and rotationMatrixToEulerXYZ().

Referenced by momentum::JointParametersT< T >::fromRotationMatrix(), and rotationMatrixToEulerXYZ().

◆ rotationMatrixToOneAxisEuler() [1/3]

template double momentum::rotationMatrixToOneAxisEuler ( const Matrix3< double > &  m,
int  axis0 
)

◆ rotationMatrixToOneAxisEuler() [2/3]

template float momentum::rotationMatrixToOneAxisEuler ( const Matrix3< float > &  m,
int  axis0 
)

◆ rotationMatrixToOneAxisEuler() [3/3]

template<typename T >
T momentum::rotationMatrixToOneAxisEuler ( const Matrix3< T > &  m,
int  axis0 
)

Fits a single-axis Euler rotation to a rotation matrix.

Finds the best-fit single-axis rotation angle that minimizes the L2 distance to the target rotation matrix using Levenberg-Marquardt optimization. This is NOT a direct conversion - if the input matrix cannot be exactly represented as a single-axis rotation, this function returns the closest approximation.

For exact single-axis rotations, the result will be precise. For general rotation matrices (e.g., those involving rotations around multiple axes), the result is the best single-axis approximation in the least-squares sense.

Template Parameters
TThe scalar type.
Parameters
[in]mThe target rotation matrix.
[in]axis0The rotation axis index, one of {0, 1, 2} (X, Y, Z).
Returns
The fitted rotation angle around the specified axis.

Definition at line 785 of file utility.cpp.

References MT_CHECK.

Referenced by rotationMatrixToTwoAxisEuler().

◆ rotationMatrixToTwoAxisEuler() [1/3]

template Vector2< double > momentum::rotationMatrixToTwoAxisEuler ( const Matrix3< double > &  m,
int  axis0,
int  axis1 
)

◆ rotationMatrixToTwoAxisEuler() [2/3]

template Vector2< float > momentum::rotationMatrixToTwoAxisEuler ( const Matrix3< float > &  m,
int  axis0,
int  axis1 
)

◆ rotationMatrixToTwoAxisEuler() [3/3]

template<typename T >
Vector2< T > momentum::rotationMatrixToTwoAxisEuler ( const Matrix3< T > &  m,
int  axis0,
int  axis1 
)

Fits a two-axis Euler rotation to a rotation matrix.

Finds the best-fit two-axis Euler angles (axis0 then axis1) that minimize the L2 distance to the target rotation matrix using Levenberg-Marquardt optimization.

Template Parameters
TThe scalar type.
Parameters
[in]mThe target rotation matrix.
[in]axis0The index of the first rotation axis, one of {0, 1, 2}.
[in]axis1The index of the second rotation axis, one of {0, 1, 2}.
Returns
A 2D vector containing the fitted Euler angles [angle0, angle1].

Definition at line 808 of file utility.cpp.

References MT_CHECK, and rotationMatrixToOneAxisEuler().

◆ roundUpToAlignment()

constexpr std::size_t momentum::roundUpToAlignment ( std::size_t  value,
std::size_t  alignment 
)
inlineconstexpr

Definition at line 52 of file aligned.h.

References MT_THROW_IF_T.

Referenced by alignedAlloc().

◆ sampleFrames()

std::vector< size_t > momentum::sampleFrames ( momentum::Character character,
const MatrixXf initialMotion,
std::span< const std::vector< momentum::Marker > >  markerData,
const ParameterSet parameters,
const size_t  frameStride,
const size_t  numSamples 
)

Sample representative frames from motion data to maximize parameter variance.

Uses a greedy algorithm to select frames that are maximally different from each other in parameter space, while filtering out frames with high marker tracking errors. This is useful for calibration where you want to solve on a diverse set of poses rather than all frames.

Parameters
characterThe character model used for computing marker errors
initialMotionInitial motion parameters matrix (parameters x frames)
markerDataMarker observations for each frame
parametersSet of parameters to consider for variance calculation
frameStrideOnly consider every frameStride-th frame as candidates
numSamplesMaximum number of frames to sample
Returns
Vector of frame indices representing the selected keyframes

Definition at line 55 of file marker_tracker.cpp.

References momentum::CharacterT< T >::locators, momentum::CharacterT< T >::parameterTransform, momentum::SkeletonStateT< T >::set(), and momentum::CharacterT< T >::skeleton.

Referenced by calibrateLocators(), and calibrateModel().

◆ saveBlendShape() [1/2]

void momentum::saveBlendShape ( const filesystem::path &  filename,
const BlendShape blendShape 
)

Saves a blend shape to a file.

Parameters
filenameOutput file path for the blend shape data
blendShapeBlendShape object to save

Definition at line 129 of file blend_shape_io.cpp.

References MT_LOGW, and saveBlendShape().

Referenced by saveBlendShape().

◆ saveBlendShape() [2/2]

void momentum::saveBlendShape ( std::ostream &  os,
const BlendShape blendShape 
)

Saves a blend shape to a stream.

Parameters
osOutput stream to write blend shape data
blendShapeBlendShape object to save

Definition at line 150 of file blend_shape_io.cpp.

References momentum::BlendShape::getBaseShape(), momentum::BlendShapeBase::getShapeVectors(), and MT_CHECK.

◆ saveBlendShapeBase() [1/2]

void momentum::saveBlendShapeBase ( const filesystem::path &  filename,
const BlendShapeBase blendShapeBase 
)

Saves a blend shape base (shape vectors) to a file.

Parameters
filenameOutput file path for the blend shape data
blendShapeBaseBlendShapeBase object to save

Definition at line 120 of file blend_shape_io.cpp.

References MT_LOGW, and saveBlendShapeBase().

Referenced by saveBlendShapeBase().

◆ saveBlendShapeBase() [2/2]

void momentum::saveBlendShapeBase ( std::ostream &  os,
const BlendShapeBase blendShapeBase 
)

Saves a blend shape base (shape vectors) to a stream.

Parameters
osOutput stream to write blend shape data
blendShapeBaseBlendShapeBase object to save

Definition at line 138 of file blend_shape_io.cpp.

◆ saveCharacter() [1/2]

void momentum::saveCharacter ( const filesystem::path &  filename,
const Character character,
float  fps,
std::span< const SkeletonState skeletonStates,
std::span< const std::vector< Marker > >  markerSequence = {},
const FileSaveOptions options = FileSaveOptions() 
)

High level function to save a character with motion in skeleton states and markers to any supported format.

The format is determined by the file extension (.fbx, .glb, .gltf). This is a unified interface that automatically selects between FBX and GLTF based on extension.

Parameters
[in]filenameThe path where the character file will be saved.
[in]characterThe Character object to save.
[in]fpsFrame rate for the animation.
[in]skeletonStatesThe motion represented in skeleton states (ie. JointStates).
[in]markerSequenceOptional marker sequence data to save with the character.
[in]optionsOptional file save options for controlling output (default: FileSaveOptions{}).

Definition at line 180 of file character_io.cpp.

References Fbx, Gltf, MT_THROW, MT_THROW_IF, saveFbxWithSkeletonStates(), saveGltfCharacter(), and Unknown.

◆ saveCharacter() [2/2]

void momentum::saveCharacter ( const filesystem::path &  filename,
const Character character,
float  fps = 120.f,
const MatrixXf motion = MatrixXf(),
std::span< const std::vector< Marker > >  markerSequence = {},
const FileSaveOptions options = FileSaveOptions() 
)

High level function to save a character with motion and markers to any supported format.

The format is determined by the file extension (.fbx, .glb, .gltf). This is a unified interface that automatically selects between FBX and GLTF based on extension.

Parameters
[in]filenameThe path where the character file will be saved.
[in]characterThe Character object to save.
[in]fpsFrame rate for the animation (default: 120.0f).
[in]motionThe motion represented in model parameters (numModelParams, numFrames).
[in]markerSequenceOptional marker sequence data to save with the character.
[in]optionsOptional file save options for controlling output (default: FileSaveOptions{}).

Definition at line 147 of file character_io.cpp.

References Fbx, Gltf, MT_THROW, MT_THROW_IF, momentum::ParameterTransformT< T >::name, momentum::CharacterT< T >::parameterTransform, saveFbx(), saveGltfCharacter(), and Unknown.

◆ saveCharacterToBytes()

std::vector< std::byte > momentum::saveCharacterToBytes ( const Character character,
float  fps = 120.0f,
const MotionParameters motion = {},
const IdentityParameters offsets = {},
std::span< const std::vector< Marker > >  markerSequence = {},
const FileSaveOptions options = FileSaveOptions(),
std::span< const int64_t timestamps = {} 
)

Save a character with motion to a byte buffer.

This function saves a character along with optional motion data, identity parameters, and marker sequences to a byte buffer instead of a file.

Parameters
[in]characterThe Character object to save.
[in]fpsFrame rate of the motion in frames per second (default: 120.0f).
[in]motionOptional motion parameters to save (default: empty).
[in]offsetsOptional identity parameters capturing skeleton bone lengths (default: empty).
[in]markerSequenceOptional marker sequence data to save (default: empty).
[in]optionsOptional file save options for controlling output (default: FileSaveOptions{}).
[in]timestampsOptional per-frame timestamps. Size should match motion columns.
Returns
A byte buffer containing the glTF data.

Definition at line 1578 of file gltf_io.cpp.

References makeCharacterDocument().

◆ saveCharacterToLegacyJson()

void momentum::saveCharacterToLegacyJson ( const Character character,
const std::string &  jsonPath 
)

Saves a Character to legacy JSON format.

This function converts a momentum::Character back to the legacy JSON format for compatibility with existing tools and workflows.

Parameters
[in]characterThe Character to save
[in]jsonPathPath where to save the legacy JSON file
Exceptions
std::runtime_errorif the file cannot be written

Definition at line 566 of file legacy_json_io.cpp.

References characterToLegacyJson(), and MT_THROW_IF.

◆ saveFbx()

void momentum::saveFbx ( const filesystem::path &  filename,
const Character character,
const MatrixXf poses = MatrixXf(),
const VectorXf identity = VectorXf(),
double  framerate = 120.0,
std::span< const std::vector< Marker > >  markerSequence = {},
const FileSaveOptions options = FileSaveOptions() 
)

Save a character with animation to an FBX file.

Parameters
filenamePath to the output FBX file
characterThe character to save
posesModel parameters for each frame (empty for bind pose only)
identityIdentity pose parameters (empty to use bind pose)
framerateAnimation framerate in frames per second
markerSequenceOptional marker sequence data to save with the character
optionsOptional file save options for controlling output (default: FileSaveOptions{})

Definition at line 973 of file fbx_io.cpp.

References MT_THROW.

Referenced by saveCharacter(), and saveMotion().

◆ saveFbxModel()

void momentum::saveFbxModel ( const filesystem::path &  filename,
const Character character,
const FileSaveOptions options = FileSaveOptions() 
)

Save a character model (skeleton and mesh) without animation.

Parameters
filenamePath to the output FBX file
characterThe character to save
optionsOptional file save options for controlling output (default: FileSaveOptions{})

Definition at line 1007 of file fbx_io.cpp.

References MT_THROW.

◆ saveFbxWithJointParams()

void momentum::saveFbxWithJointParams ( const filesystem::path &  filename,
const Character character,
const MatrixXf jointParams = MatrixXf(),
double  framerate = 120.0,
std::span< const std::vector< Marker > >  markerSequence = {},
const FileSaveOptions options = FileSaveOptions() 
)

Save a character with animation using joint parameters directly.

Parameters
filenamePath to the output FBX file
characterThe character to save
jointParamsJoint parameters for each frame (empty for bind pose only)
framerateAnimation framerate in frames per second
markerSequenceOptional marker sequence data to save with the character
optionsOptional file save options for controlling output (default: FileSaveOptions{})

Definition at line 985 of file fbx_io.cpp.

References MT_THROW.

◆ saveFbxWithSkeletonStates()

void momentum::saveFbxWithSkeletonStates ( const filesystem::path &  filename,
const Character character,
std::span< const SkeletonState skeletonStates,
double  framerate = 120.0,
std::span< const std::vector< Marker > >  markerSequence = {},
const FileSaveOptions options = FileSaveOptions() 
)

Save a character with animation using skeleton states directly.

Parameters
filenamePath to the output FBX file
characterThe character to save
skeletonStatesSkeletonState for each frame (empty for bind pose only)
framerateAnimation framerate in frames per second
markerSequenceOptional marker sequence data to save with the character
optionsOptional file save options for controlling output (default: FileSaveOptions{})

Definition at line 996 of file fbx_io.cpp.

References MT_THROW.

Referenced by saveCharacter().

◆ saveGltfCharacter() [1/2]

void momentum::saveGltfCharacter ( const filesystem::path &  filename,
const Character character,
float  fps,
std::span< const SkeletonState skeletonStates,
std::span< const std::vector< Marker > >  markerSequence = {},
const FileSaveOptions options = FileSaveOptions() 
)

Save a character with skeleton states to a glTF file.

This function saves a character along with skeleton states (transform matrices for each joint at each frame) to a glTF file. This is an alternative to saving model parameters.

Parameters
[in]filenameThe path where the glTF file will be saved.
[in]characterThe Character object to save.
[in]fpsFrame rate of the motion in frames per second.
[in]skeletonStatesThe skeleton states for each frame of the motion sequence.
[in]markerSequenceOptional marker sequence data to save (default: empty).
[in]optionsOptional file save options for controlling output (default: FileSaveOptions{}).

Definition at line 1564 of file gltf_io.cpp.

References makeCharacterDocument(), and momentum::GltfBuilder::save().

◆ saveGltfCharacter() [2/2]

void momentum::saveGltfCharacter ( const filesystem::path &  filename,
const Character character,
float  fps = 120.0f,
const MotionParameters motion = {},
const IdentityParameters offsets = {},
std::span< const std::vector< Marker > >  markerSequence = {},
const FileSaveOptions options = FileSaveOptions(),
std::span< const int64_t timestamps = {} 
)

Save a character with motion to a glTF file.

This function saves a character along with optional motion data, identity parameters, and marker sequences to a glTF file.

Parameters
[in]filenameThe path where the glTF file will be saved.
[in]characterThe Character object to save.
[in]fpsFrame rate of the motion in frames per second (default: 120.0f).
[in]motionOptional motion parameters to save (default: empty).
[in]offsetsOptional identity parameters capturing skeleton bone lengths (default: empty).
[in]markerSequenceOptional marker sequence data to save (default: empty).
[in]optionsOptional file save options for controlling output (default: FileSaveOptions{}).
[in]timestampsOptional per-frame timestamps. Size should match motion columns.

Definition at line 1548 of file gltf_io.cpp.

References makeCharacterDocument(), and momentum::GltfBuilder::save().

Referenced by saveCharacter(), and saveCharacter().

◆ saveLocators()

void momentum::saveLocators ( const filesystem::path &  filename,
const LocatorList locators,
const Skeleton skeleton,
const LocatorSpace  space 
)

◆ saveMmo() [1/3]

void momentum::saveMmo ( const std::string &  filename,
const MatrixXf poses,
const VectorXf scale,
const Character character,
const MatrixXf additionalParameters = MatrixXf(),
std::span< const std::string >  additionalParameterNames = std::vector< std::string >() 
)

Save motion data with optional additional parameters.

Parameters
filenameOutput file path
posesMotion poses matrix (parameters x frames)
scaleJoint scale parameters
characterCharacter definition for parameter mapping
additionalParametersExtra parameters to store alongside poses
additionalParameterNamesNames for additional parameters

Definition at line 43 of file mmo_io.cpp.

References momentum::SkeletonT< T >::joints, kParametersPerJoint, MT_LOGW, momentum::ParameterTransformT< T >::name, momentum::ParameterTransformT< T >::numAllModelParameters(), momentum::CharacterT< T >::parameterTransform, saveMmo(), and momentum::CharacterT< T >::skeleton.

◆ saveMmo() [2/3]

void momentum::saveMmo ( const std::string &  filename,
const MatrixXf poses,
const VectorXf scale,
std::span< const std::string >  parameterNames,
std::span< const std::string >  jointNames 
)

Save motion data with explicit parameter and joint names.

Parameters
filenameOutput file path
posesMotion poses matrix (parameters x frames)
scaleJoint scale parameters
parameterNamesNames of motion parameters
jointNamesNames of skeleton joints

Definition at line 113 of file mmo_io.cpp.

References kParametersPerJoint, and MT_LOGW.

◆ saveMmo() [3/3]

void momentum::saveMmo ( const std::string &  filename,
std::span< const VectorXf poses,
const VectorXf scale,
const Character character 
)

Save motion data using character parameter mapping.

Parameters
filenameOutput file path
posesMotion poses as span of vectors, each vector represents one frame
scaleJoint scale parameters
characterCharacter definition for parameter mapping

Definition at line 17 of file mmo_io.cpp.

References MT_LOGW, momentum::ParameterTransformT< T >::numAllModelParameters(), momentum::CharacterT< T >::parameterTransform, and saveMmo().

Referenced by saveMmo(), and saveMmo().

◆ saveMotion()

void momentum::saveMotion ( const std::string &  outFile,
const momentum::Character character,
const momentum::ModelParameters identity,
Eigen::MatrixXf &  finalMotion,
std::span< const std::vector< momentum::Marker > >  markerData,
double  fps,
bool  saveMarkerMesh = true,
std::span< const int64_t timestamps = {} 
)

Save the given character and motion to a GLB or FBX file.

Parameters
[in]outFileThe GLB/FBX file to save to
[in]characterThe GLB/FBX file to save to
[in]identityThe identity parameters used for the character
[in]finalMotionThe motion save to the file. (Note: this may be modified to remove scaling parameters if saveScaleToMotion is false)
[in]markerDataMarker data to save to the file
[in]fpsFramerate of the motion
[in]saveMarkerMesh(optional) Whether to save a visible cube mesh for the markers
[in]saveScaleToMotion(optional) Whether to save the scale parameters to the motion or identity parameter vectors (saving to motion is preferred)
[in]timestampsPer-frame timestamps. Size should match motion columns.

Definition at line 189 of file app_utils.cpp.

References momentum::GltfBuilder::addMotion(), momentum::ParameterTransformT< T >::apply(), extractParameters(), momentum::SkeletonT< T >::getJointNames(), momentum::ParameterTransformT< T >::getScalingParameters(), momentum::ParameterTransformT< T >::name, momentum::GltfBuilder::None, momentum::CharacterT< T >::parameterTransform, removeIdentity(), saveFbx(), momentum::CharacterT< T >::skeleton, momentum::GltfBuilder::UnitCube, and momentum::EigenStrongType< Derived, EigenType >::v.

Referenced by processMarkerFile().

◆ saveMppca()

void momentum::saveMppca ( const Mppca mppca,
const std::string &  name 
)

Definition at line 84 of file mppca_io.cpp.

References MT_CHECK.

◆ saveUsd()

void momentum::saveUsd ( const filesystem::path &  filename,
const Character character 
)

Save a character to a USD file.

Parameters
[in]filenameThe path to save the USD file.
[in]characterThe Character object to save.

Definition at line 510 of file usd_io.cpp.

References momentum::SkeletonT< T >::joints, momentum::CharacterT< T >::mesh, MT_THROW_IF, momentum::CharacterT< T >::skeleton, skeleton, and momentum::CharacterT< T >::skinWeights.

◆ scaleCharacter()

Character momentum::scaleCharacter ( const Character character,
float  scale 
)

Scales the character (mesh and skeleton) by the desired amount.

Note that this should primarily be used when transforming the character into different units. If you simply want to apply an identity-specific scale to the character, you should use the 'scale_global' parameter in the ParameterTransform class.

Parameters
[in]characterCharacter to be scaled
[in]scaleScale factor to apply
Returns
A new Character object that has been scaled

Definition at line 312 of file character_utility.cpp.

References momentum::CharacterT< T >::blendShape, momentum::CharacterT< T >::collision, momentum::CharacterT< T >::faceExpressionBlendShape, momentum::CharacterT< T >::inverseBindPose, momentum::CharacterT< T >::locators, momentum::CharacterT< T >::mesh, momentum::CharacterT< T >::name, momentum::CharacterT< T >::parameterLimits, momentum::CharacterT< T >::parameterTransform, momentum::CharacterT< T >::poseShapes, momentum::CharacterT< T >::skeleton, and momentum::CharacterT< T >::skinWeights.

◆ setAccessorType()

template<typename T >
void momentum::setAccessorType ( fx::gltf::Accessor &  )

Definition at line 128 of file accessor_utils.h.

References MT_THROW.

◆ setAccessorType< const float >()

template<>
void momentum::setAccessorType< const float > ( fx::gltf::Accessor &  accessor)
inline

Definition at line 212 of file accessor_utils.h.

◆ setAccessorType< const int32_t >()

template<>
void momentum::setAccessorType< const int32_t > ( fx::gltf::Accessor &  accessor)
inline

Definition at line 206 of file accessor_utils.h.

◆ setAccessorType< const Matrix4f >()

template<>
void momentum::setAccessorType< const Matrix4f > ( fx::gltf::Accessor &  accessor)
inline

Definition at line 260 of file accessor_utils.h.

◆ setAccessorType< const Vector2f >()

template<>
void momentum::setAccessorType< const Vector2f > ( fx::gltf::Accessor &  accessor)
inline

Definition at line 218 of file accessor_utils.h.

◆ setAccessorType< const Vector3b >()

template<>
void momentum::setAccessorType< const Vector3b > ( fx::gltf::Accessor &  accessor)
inline

Definition at line 236 of file accessor_utils.h.

◆ setAccessorType< const Vector3f >()

template<>
void momentum::setAccessorType< const Vector3f > ( fx::gltf::Accessor &  accessor)
inline

Definition at line 224 of file accessor_utils.h.

◆ setAccessorType< const Vector3i >()

template<>
void momentum::setAccessorType< const Vector3i > ( fx::gltf::Accessor &  accessor)
inline

Definition at line 242 of file accessor_utils.h.

◆ setAccessorType< const Vector4b >()

template<>
void momentum::setAccessorType< const Vector4b > ( fx::gltf::Accessor &  accessor)
inline

Definition at line 254 of file accessor_utils.h.

◆ setAccessorType< const Vector4f >()

template<>
void momentum::setAccessorType< const Vector4f > ( fx::gltf::Accessor &  accessor)
inline

Definition at line 230 of file accessor_utils.h.

◆ setAccessorType< const Vector4s >()

template<>
void momentum::setAccessorType< const Vector4s > ( fx::gltf::Accessor &  accessor)
inline

Definition at line 248 of file accessor_utils.h.

◆ setLogLevel() [1/2]

void momentum::setLogLevel ( const std::string &  levelStr)

Definition at line 89 of file log.cpp.

References setLogLevel().

◆ setLogLevel() [2/2]

void momentum::setLogLevel ( LogLevel  level)

Definition at line 80 of file log.cpp.

References MT_LOGW.

Referenced by setLogLevel().

◆ setTimeSeconds()

void momentum::setTimeSeconds ( const rerun::RecordingStream &  rec,
const std::string &  timelineName,
double  seconds 
)
inline

Definition at line 64 of file rerun_compat.h.

◆ skeletonStateToJointParameters() [1/6]

template JointParametersT< double > momentum::skeletonStateToJointParameters ( const SkeletonStateT< double > &  state,
const Skeleton skeleton 
)

◆ skeletonStateToJointParameters() [2/6]

template JointParametersT< float > momentum::skeletonStateToJointParameters ( const SkeletonStateT< float > &  state,
const Skeleton skeleton 
)

◆ skeletonStateToJointParameters() [3/6]

template<typename T >
JointParametersT< T > momentum::skeletonStateToJointParameters ( const SkeletonStateT< T > &  state,
const Skeleton skeleton 
)

Invert the skeleton state (global transforms in world space) back to joint parameters (Euler angles in local space).

Note that this conversion is not unique due to the non-uniqueness of Euler angle conversion.

Definition at line 250 of file skeleton_state.cpp.

References momentum::SkeletonT< T >::joints, kInvalidIndex, kParametersPerJoint, skeleton, momentum::EigenStrongType< Derived, EigenType >::v, and momentum::EigenStrongType< JointParametersT, ::Eigen::VectorX< T > >::Zero().

◆ skeletonStateToJointParameters() [4/6]

template JointParametersT< double > momentum::skeletonStateToJointParameters ( const TransformListT< double > &  state,
const Skeleton skeleton 
)

◆ skeletonStateToJointParameters() [5/6]

template JointParametersT< float > momentum::skeletonStateToJointParameters ( const TransformListT< float > &  state,
const Skeleton skeleton 
)

◆ skeletonStateToJointParameters() [6/6]

◆ skeletonStateToJointParametersRespectingActiveParameters() [1/6]

template JointParametersT< double > momentum::skeletonStateToJointParametersRespectingActiveParameters ( const SkeletonStateT< double > &  state,
const Skeleton skeleton,
const VectorX< bool > &  activeJointParams 
)

◆ skeletonStateToJointParametersRespectingActiveParameters() [2/6]

template JointParametersT< float > momentum::skeletonStateToJointParametersRespectingActiveParameters ( const SkeletonStateT< float > &  state,
const Skeleton skeleton,
const VectorX< bool > &  activeJointParams 
)

◆ skeletonStateToJointParametersRespectingActiveParameters() [3/6]

template<typename T >
JointParametersT< T > momentum::skeletonStateToJointParametersRespectingActiveParameters ( const SkeletonStateT< T > &  state,
const Skeleton skeleton,
const VectorX< bool > &  activeJointParams 
)

Converts skeleton state back to joint parameters, respecting active joint parameter constraints.

This function addresses the limitation of the original skeletonStateToJointParameters which always uses 3-axis Euler rotations. Many joints only support 1-axis or 2-axis rotations, so this function uses the provided activeJointParams to determine how many rotation axes are active for each joint and applies the appropriate conversion method:

  • 0 active rotation axes: Sets all rotation parameters to zero
  • 1 active rotation axis: Uses rotationMatrixToOneAxisEuler
  • 2 active rotation axes: Uses rotationMatrixToTwoAxisEuler
  • 3 active rotation axes: Uses the standard 3-axis Euler conversion
Template Parameters
TThe scalar type (float or double)
Parameters
[in]stateThe skeleton state to convert
[in]skeletonThe skeleton defining joint hierarchy and properties
[in]activeJointParamsBoolean array indicating which joint parameters are active. Size should be skeleton.joints.size() * kParametersPerJoint
Returns
Joint parameters with rotations respecting the active parameter constraints

Definition at line 371 of file skeleton_state.cpp.

References momentum::SkeletonT< T >::joints, kInvalidIndex, kParametersPerJoint, MT_CHECK, skeleton, momentum::EigenStrongType< Derived, EigenType >::v, and momentum::EigenStrongType< JointParametersT, ::Eigen::VectorX< T > >::Zero().

◆ skeletonStateToJointParametersRespectingActiveParameters() [4/6]

template JointParametersT< double > momentum::skeletonStateToJointParametersRespectingActiveParameters ( const TransformListT< double > &  state,
const Skeleton skeleton,
const VectorX< bool > &  activeJointParams 
)

◆ skeletonStateToJointParametersRespectingActiveParameters() [5/6]

template JointParametersT< float > momentum::skeletonStateToJointParametersRespectingActiveParameters ( const TransformListT< float > &  state,
const Skeleton skeleton,
const VectorX< bool > &  activeJointParams 
)

◆ skeletonStateToJointParametersRespectingActiveParameters() [6/6]

template<typename T >
JointParametersT< T > momentum::skeletonStateToJointParametersRespectingActiveParameters ( const TransformListT< T > &  state,
const Skeleton skeleton,
const VectorX< bool > &  activeJointParams 
)

Converts transform list back to joint parameters, respecting active joint parameter constraints.

This function addresses the limitation of the original skeletonStateToJointParameters which always uses 3-axis Euler rotations. Many joints only support 1-axis or 2-axis rotations, so this function uses the provided activeJointParams to determine how many rotation axes are active for each joint and applies the appropriate conversion method:

  • 0 active rotation axes: Sets all rotation parameters to zero
  • 1 active rotation axis: Uses rotationMatrixToOneAxisEuler
  • 2 active rotation axes: Uses rotationMatrixToTwoAxisEuler
  • 3 active rotation axes: Uses the standard 3-axis Euler conversion
Template Parameters
TThe scalar type (float or double)
Parameters
[in]stateThe transform list to convert
[in]skeletonThe skeleton defining joint hierarchy and properties
[in]activeJointParamsBoolean array indicating which joint parameters are active. Size should be skeleton.joints.size() * kParametersPerJoint
Returns
Joint parameters with rotations respecting the active parameter constraints

Definition at line 404 of file skeleton_state.cpp.

References momentum::SkeletonT< T >::joints, kInvalidIndex, kParametersPerJoint, MT_CHECK, skeleton, momentum::EigenStrongType< Derived, EigenType >::v, and momentum::EigenStrongType< JointParametersT, ::Eigen::VectorX< T > >::Zero().

◆ skinnedLocatorsToLocators()

momentum::Character momentum::skinnedLocatorsToLocators ( const momentum::Character sourceCharacter)

Convert skinned locators to regular locators by selecting the bone with the highest skin weight.

This is useful when exporting to file formats that don't support skinned locators (e.g., Maya). Each skinned locator will be converted to a regular locator attached to the bone with the highest weight. The position will be transformed from the rest pose space to the local space of the selected bone.

Parameters
sourceCharacterCharacter with skinned locators to convert
Returns
Character with skinned locators converted to regular locators

Definition at line 324 of file tracker_utils.cpp.

References kMaxSkinJoints, MT_LOGI, MT_LOGT, momentum::Locator::name, and momentum::EigenStrongType< Derived, EigenType >::Zero().

◆ skinWithBlendShapes() [1/6]

template void momentum::skinWithBlendShapes ( const Character character,
const SkeletonStateT< double > &  state,
const BlendWeightsT< double > &  modelParams,
MeshT< double > &  outputMesh 
)

References skinWithBlendShapes().

◆ skinWithBlendShapes() [2/6]

template void momentum::skinWithBlendShapes ( const Character character,
const SkeletonStateT< double > &  state,
const ModelParametersT< double > &  modelParams,
MeshT< double > &  outputMesh 
)

References skinWithBlendShapes().

◆ skinWithBlendShapes() [3/6]

template void momentum::skinWithBlendShapes ( const Character character,
const SkeletonStateT< float > &  state,
const BlendWeightsT< float > &  modelParams,
MeshT< float > &  outputMesh 
)

References skinWithBlendShapes().

◆ skinWithBlendShapes() [4/6]

template void momentum::skinWithBlendShapes ( const Character character,
const SkeletonStateT< float > &  state,
const ModelParametersT< float > &  modelParams,
MeshT< float > &  outputMesh 
)

References skinWithBlendShapes().

◆ skinWithBlendShapes() [5/6]

template<typename T >
void momentum::skinWithBlendShapes ( const Character character,
const SkeletonStateT< T > &  state,
const BlendWeightsT< T > &  blendWeights,
MeshT< T > &  outputMesh 
)

Applies blend shape deformations and skeletal transformations to a mesh.

Computes the final vertex positions by applying blend shape offsets to the base mesh, then transforming the resulting vertices using linear blend skinning based on the skeleton state. Use this version when you already have pre-calculated blend weights.

Parameters
characterCharacter containing mesh, blend shapes, and skinning data
stateCurrent pose of the skeleton
blendWeightsWeights for each blend shape
outputMeshMesh to store the resulting deformed vertices

Definition at line 60 of file blend_shape_skinning.cpp.

References momentum::CharacterT< T >::blendShape, momentum::CharacterT< T >::inverseBindPose, momentum::CharacterT< T >::mesh, MT_CHECK, and momentum::CharacterT< T >::skinWeights.

◆ skinWithBlendShapes() [6/6]

template<typename T >
void momentum::skinWithBlendShapes ( const Character character,
const SkeletonStateT< T > &  state,
const ModelParametersT< T > &  modelParams,
MeshT< T > &  outputMesh 
)

Applies blend shape deformations and skeletal transformations to a mesh.

Overload that extracts blend shape weights from model parameters before skinning. Use this version when working with high-level character animation where you have model parameters rather than direct blend weights.

Parameters
characterCharacter containing mesh, blend shapes, and skinning data
stateCurrent pose of the skeleton
modelParamsModel parameters containing blend shape weights
outputMeshMesh to store the resulting deformed vertices

Definition at line 50 of file blend_shape_skinning.cpp.

References extractBlendWeights(), momentum::CharacterT< T >::parameterTransform, and skinWithBlendShapes().

Referenced by momentum::CharacterStateT< T >::set(), skinWithBlendShapes(), skinWithBlendShapes(), skinWithBlendShapes(), skinWithBlendShapes(), and skinWithBlendShapes().

◆ slerp() [1/3]

template TransformT< double > momentum::slerp ( const TransformT< double > &  ,
const TransformT< double > &  ,
double   
)

◆ slerp() [2/3]

template TransformT< float > momentum::slerp ( const TransformT< float > &  ,
const TransformT< float > &  ,
float   
)

◆ slerp() [3/3]

template<typename T >
TransformT< T > momentum::slerp ( const TransformT< T > &  t1,
const TransformT< T > &  t2,
T  weight 
)

Spherical linear interpolation between two transforms.

Definition at line 144 of file transform.cpp.

◆ sqr() [1/2]

◆ sqr() [2/2]

float momentum::sqr ( float  val)

Definition at line 70 of file fully_differentiable_body_ik.cpp.

◆ subsetParameterTransform() [1/3]

template std::tuple< ParameterTransformT< double >, ParameterLimits > momentum::subsetParameterTransform ( const ParameterTransformT< double > &  paramTransform,
const ParameterLimits parameterLimits,
const ParameterSet paramSet 
)

◆ subsetParameterTransform() [2/3]

template std::tuple< ParameterTransformT< float >, ParameterLimits > momentum::subsetParameterTransform ( const ParameterTransformT< float > &  paramTransform,
const ParameterLimits parameterLimits,
const ParameterSet paramSet 
)

◆ subsetParameterTransform() [3/3]

◆ subsetVecToFullVec()

template<typename T >
Eigen::VectorX< T > momentum::subsetVecToFullVec ( Eigen::Ref< const Eigen::VectorX< T > >  subsetVec,
const std::vector< Eigen::Index > &  subsetIndexToFullParamIndex,
Eigen::Index  fullVecSize 
)

Definition at line 59 of file fully_differentiable_body_ik.cpp.

◆ times_parameterTransform_times_v()

template<typename T , typename T2 >
T momentum::times_parameterTransform_times_v ( const T value,
const size_t  jointParamIdx,
const ParameterTransform parameterTransform,
Eigen::Ref< const Eigen::VectorX< T2 > >  v 
)

◆ toCm()

template<typename T = float>
constexpr T momentum::toCm ( T  x = T(1))
constexprnoexcept

Converts the given length x (in meters) to centimeters.

If called without an argument, it returns the conversion factor from meters to centimeters.

Definition at line 77 of file constants.h.

Referenced by toMomentumVec3f(), and toMomentumVec3f().

◆ toColumnMajor()

template<typename T >
Eigen::SparseMatrix< T > momentum::toColumnMajor ( const SparseRowMatrix< T > &  mat)

Definition at line 16 of file inverse_parameter_transform.cpp.

◆ toDeg()

template<typename T = float>
constexpr T momentum::toDeg ( T  x = T(1))
constexprnoexcept

Converts the given angle x (in radians) to degrees.

If called without an argument, it returns the conversion factor from radians to degrees.

Definition at line 59 of file constants.h.

Referenced by writeParameterLimits().

◆ toJson()

template<typename Derived >
void momentum::toJson ( const Eigen::MatrixBase< Derived > &  mat,
nlohmann::json &  j 
)

Definition at line 25 of file json_utils.h.

Referenced by parameterLimitsToJson().

◆ tokenize() [1/2]

std::vector< std::string > momentum::tokenize ( const std::string &  inputString,
const std::string &  delimiters = " \t\r\n",
bool  trim = true 
)

Tokenize a string using the specified delimiters.

Parameters
inputStringThe string to tokenize.
delimitersThe string containing delimiter characters.
trimWhether to trim spaces around the tokens (default: true).
Returns
A vector of tokenized strings.

Definition at line 42 of file string.cpp.

References trim().

Referenced by loadTrc(), parseParameterSets(), parseParameterTransform(), and parsePoseConstraints().

◆ tokenize() [2/2]

std::vector< std::string_view > momentum::tokenize ( std::string_view  inputString,
std::string_view  delimiters = " \t\r\n",
bool  trim = true 
)

Tokenize a string_view using the specified delimiters.

Parameters
inputStringThe string_view to tokenize.
delimitersThe string_view containing delimiter characters.
trimWhether to trim spaces around the tokens (default: true).
Returns
A vector of tokenized string_views.

Definition at line 70 of file string.cpp.

References trim().

◆ toM()

template<typename T = float>
constexpr T momentum::toM ( T  x = T(1))
constexprnoexcept

Converts the given length x (in centimeters) to meters.

If called without an argument, it returns the conversion factor from centimeters to meters.

Definition at line 68 of file constants.h.

Referenced by fromMomentumVec3f(), fromMomentumVec3f(), fromMomentumVec3f(), parameterLimitsFromJson(), and parameterLimitsToJson().

◆ toMomentumQuaternionf()

Quaternionf momentum::toMomentumQuaternionf ( const std::array< float, 4 > &  gltfQuat)
inlinenoexcept

Definition at line 26 of file coordinate_utils.h.

◆ toMomentumVec3f() [1/2]

Vector3f momentum::toMomentumVec3f ( const std::array< float, 3 > &  vec)
inlinenoexcept

Definition at line 18 of file coordinate_utils.h.

References toCm().

Referenced by loadMarkerSequence().

◆ toMomentumVec3f() [2/2]

void momentum::toMomentumVec3f ( std::vector< Vector3f > &  vec)
inline

Definition at line 36 of file coordinate_utils.h.

References toCm().

◆ toMomentumVector3() [1/6]

template Vector3< double > momentum::toMomentumVector3 ( const Vector3< double > &  vec,
UpVector  up,
const std::string &  unitStr 
)

◆ toMomentumVector3() [2/6]

template Vector3< double > momentum::toMomentumVector3 ( const Vector3< double > &  vec,
UpVector  up,
Unit  unit 
)

◆ toMomentumVector3() [3/6]

template Vector3< float > momentum::toMomentumVector3 ( const Vector3< float > &  vec,
UpVector  up,
const std::string &  unitStr 
)

◆ toMomentumVector3() [4/6]

template Vector3< float > momentum::toMomentumVector3 ( const Vector3< float > &  vec,
UpVector  up,
Unit  unit 
)

◆ toMomentumVector3() [5/6]

template<typename T >
Vector3< T > momentum::toMomentumVector3 ( const Vector3< T > &  vec,
UpVector  up,
const std::string &  unitStr 
)

This function converts a 3D vector in the mocap marker coordinate system to the Momentum coordinate system, using a string to specify the unit.

The mocap marker coordinate system uses a spatial index with a specified up-axis (default Z), right-handedness, and units specified in the 'unitStr' parameter (e.g., "m", "cm", "mm"). The Momentum coordinate system uses a spatial index with Y as the up-axis, right-handedness, and units in centimeters.

Template Parameters
TThe numeric type of the input and output 3D vectors.
Parameters
[in]vecThe 3D vector in the mocap marker coordinate system to be converted.
[in]up(Optional) The up-axis convention of the input marker coordinate system (default: UpVector::Z).
[in]unitStrThe string representation of the units of measurement used in the input marker coordinate system.
Returns
A 3D vector in the Momentum coordinate system.
Note
This conversion has only been tested for TRC and C3D formats.

Definition at line 101 of file conversions.cpp.

References toMomentumVector3().

◆ toMomentumVector3() [6/6]

template<typename T >
Vector3< T > momentum::toMomentumVector3 ( const Vector3< T > &  vec,
UpVector  up = UpVector::Z,
Unit  unit = Unit::MM 
)

This function converts a 3D vector in the mocap marker coordinate system to the Momentum coordinate system.

The mocap marker coordinate system uses a spatial index with a specified up-axis (default Z), right-handedness, and units specified in the 'unit' parameter (default millimeters). The Momentum coordinate system uses a spatial index with Y as the up-axis, right-handedness, and units in centimeters.

Template Parameters
TThe numeric type of the input and output 3D vectors.
Parameters
[in]vecThe 3D vector in the mocap marker coordinate system to be converted.
[in]up(Optional) The up-axis convention of the input marker coordinate system (default: UpVector::Z).
[in]unit(Optional) The units of measurement used in the input marker coordinate system (default: Unit::MM).
Returns
A 3D vector in the Momentum coordinate system.
Note
This conversion has only been tested for TRC and C3D formats.

Definition at line 49 of file conversions.cpp.

References CM, DM, M, MM, MT_LOGE, toString(), Unknown, X, Y, YNeg, and Z.

Referenced by loadC3d(), loadTrc(), and toMomentumVector3().

◆ toRad()

template<typename T = float>
constexpr T momentum::toRad ( T  x = T(1))
constexprnoexcept

Converts the given angle x (in degrees) to radians.

If called without an argument, it returns the conversion factor from degrees to radians.

Definition at line 49 of file constants.h.

◆ toString() [1/2]

◆ toString() [2/2]

std::string_view momentum::toString ( VertexConstraintType  type)

Definition at line 30 of file vertex_error_function.cpp.

◆ trackPosesForFrames() [1/2]

Eigen::MatrixXf momentum::trackPosesForFrames ( const std::span< const std::vector< Marker > >  markerData,
const Character character,
const MatrixXf initialMotion,
const TrackingConfig config,
const std::vector< size_t > &  frameIndices,
bool  isContinuous 
)

Track poses independently for specific frame indices with fixed character identity.

Similar to trackPosesPerframe, but only solves for the specified frame indices rather than processing frames with a stride. This is particularly useful during calibration when you want to solve poses only for carefully selected keyframes that have been sampled for maximum parameter variance.

Parameters
markerDataMarker observations for each frame
characterThe character model with fixed identity parameters
initialMotionInitial parameter values (parameters x frames)
configTracking configuration settings
frameIndicesVector of specific frame indices to solve
isContinuousWhether to use temporal coherence between frames
Returns
Solved motion parameters matrix (parameters x frames) with poses for selected frames

Definition at line 532 of file marker_tracker.cpp.

References momentum::CharacterT< T >::collision, createConstraintData(), createFloorConstraints< float >(), createSkinnedConstraintData(), isGlobalTransformZero(), momentum::PlaneErrorFunctionT< T >::kLegacyWeight, momentum::PositionErrorFunctionT< T >::kLegacyWeight, momentum::CharacterT< T >::locators, momentum::SolverOptions::maxIterations, MT_CHECK, MT_LOGI, MT_LOGI_IF, MT_LOGW, momentum::ParameterTransformT< T >::numAllModelParameters(), momentum::CharacterT< T >::parameterTransform, and momentum::CharacterT< T >::skinnedLocators.

Referenced by calibrateLocators(), calibrateModel(), and trackPosesPerframe().

◆ trackPosesForFrames() [2/2]

Eigen::MatrixXf momentum::trackPosesForFrames ( std::span< const std::vector< momentum::Marker > >  markerData,
const momentum::Character character,
const Eigen::MatrixXf &  initialMotion,
const TrackingConfig config,
const std::vector< size_t > &  frameIndices,
bool  isContinuous = false 
)

Track poses for given frames.

Parameters
[in]markerDataInput marker data.
[in]characterCharacter definition.
[in]globalParamsCalibrated identity info; could be repurposed to pass in an initial pose too.
[in]configSolving options.
[in]frameIndicesFrame indices of the frames to be solved.
[in]isContinuousWhether to use temporal coherence between frames.
Returns
The solved motion. It has the same length as markerData. It repeats the same solved pose within a frame stride.

◆ trackPosesPerframe() [1/2]

Eigen::MatrixXf momentum::trackPosesPerframe ( const std::span< const std::vector< Marker > >  markerData,
const Character character,
const ModelParameters globalParams,
const TrackingConfig config,
const size_t  frameStride 
)

Track poses independently per frame with fixed character identity.

This is the main production tracking function used after character calibration. It solves each frame independently using a per-frame optimizer, which makes it robust to tracking failures. The character identity (scaling, locators, blend shapes) is fixed from calibration and only pose parameters are solved.

Parameters
markerDataMarker observations for each frame
characterThe character model with calibrated identity parameters
globalParamsFixed global parameters (scaling, locators, etc.) from calibration
configTracking configuration settings
frameStrideProcess every frameStride-th frame (1 = all frames)
Returns
Solved motion parameters matrix (parameters x frames) with fixed identity

Definition at line 490 of file marker_tracker.cpp.

References MT_CHECK, and trackPosesForFrames().

Referenced by calibrateLocators(), calibrateModel(), and processMarkers().

◆ trackPosesPerframe() [2/2]

Eigen::MatrixXf momentum::trackPosesPerframe ( std::span< const std::vector< momentum::Marker > >  markerData,
const momentum::Character character,
const momentum::ModelParameters globalParams,
const TrackingConfig config,
size_t  frameStride = 1 
)

Track poses per-frame given a calibrated character.

Parameters
[in]markerDataInput marker data.
[in]characterCharacter definition.
[in]globalParamsCalibrated identity info; could be repurposed to pass in an initial pose too.
[in]configSolving options.
[in]frameStrideFrame stride to select solver frames (ie. uniform sample).
Returns
The solved motion. It has the same length as markerData. It repeats the same solved pose within a frame stride.

◆ trackSequence() [1/4]

Eigen::MatrixXf momentum::trackSequence ( const std::span< const std::vector< Marker > >  markerData,
const Character character,
const ParameterSet globalParams,
const MatrixXf initialMotion,
const TrackingConfig config,
const std::vector< size_t > &  frames,
float  regularizer,
bool  enforceFloorInFirstFrame,
const std::string &  firstFramePoseConstraintSet,
float  targetHeightCm 
)

Track motion across multiple frames simultaneously for specific frame indices.

This is the same as the main trackSequence function above, but instead of using a frameStride to sample frames uniformly, it tracks motion only for the specified frame indices. This is particularly useful during calibration when you want to solve on carefully selected keyframes rather than uniformly sampled frames.

Parameters
markerDataMarker observations for each frame
characterThe character model with skeleton, locators, and parameter transform
globalParamsSet of global parameters to solve (scaling, locators, etc.)
initialMotionInitial parameter values (parameters x frames)
configTracking configuration settings
framesVector of specific frame indices to solve
regularizerWeight for regularizing changes to global parameters
enforceFloorInFirstFrameForce floor contact constraints in first frame
firstFramePoseConstraintSetName of pose constraint set for first frame
Returns
Solved motion parameters matrix (parameters x frames)

Definition at line 239 of file marker_tracker.cpp.

References momentum::CharacterT< T >::collision, createConstraintData(), createFloorConstraints< float >(), createSkinnedConstraintData(), createSkinnedLocatorMeshConstraints(), getPoseConstraintParameterLimits(), momentum::ParameterTransformT< T >::getPoseParameters(), kAllFrames, momentum::PlaneErrorFunctionT< T >::kLegacyWeight, momentum::PositionErrorFunctionT< T >::kLegacyWeight, momentum::CharacterT< T >::locators, momentum::SolverOptions::maxIterations, MT_CHECK, MT_LOGI_IF, momentum::ParameterTransformT< T >::numAllModelParameters(), momentum::CharacterT< T >::parameterTransform, momentum::ParameterTransformT< T >::poseConstraints, momentum::CharacterT< T >::skinnedLocators, and momentum::EigenStrongType< Derived, EigenType >::Zero().

◆ trackSequence() [2/4]

Eigen::MatrixXf momentum::trackSequence ( const std::span< const std::vector< Marker > >  markerData,
const Character character,
const ParameterSet globalParams,
const MatrixXf initialMotion,
const TrackingConfig config,
float  regularizer,
const size_t  frameStride,
bool  enforceFloorInFirstFrame,
const std::string &  firstFramePoseConstraintSet,
float  targetHeightCm 
)

Track motion across multiple frames simultaneously with temporal constraints.

This is the main global optimization function that solves for both pose parameters and global parameters (scaling, locators, blend shapes) across multiple frames simultaneously. It enforces temporal smoothness constraints and can handle calibration scenarios where identity parameters need to be solved.

Parameters
markerDataMarker observations for each frame
characterThe character model with skeleton, locators, and parameter transform
globalParamsSet of global parameters to solve (scaling, locators, etc.)
initialMotionInitial parameter values (parameters x frames)
configTracking configuration settings
regularizerWeight for regularizing changes to global parameters
frameStrideProcess every frameStride-th frame (1 = all frames)
enforceFloorInFirstFrameForce floor contact constraints in first frame
firstFramePoseConstraintSetName of pose constraint set for first frame
Returns
Solved motion parameters matrix (parameters x frames)

Definition at line 191 of file marker_tracker.cpp.

References trackSequence().

Referenced by calibrateLocators(), calibrateModel(), refineMotion(), and trackSequence().

◆ trackSequence() [3/4]

Eigen::MatrixXf momentum::trackSequence ( std::span< const std::vector< momentum::Marker > >  markerData,
const momentum::Character character,
const momentum::ParameterSet globalParams,
const Eigen::MatrixXf &  initialMotion,
const TrackingConfig config,
const std::vector< size_t > &  frames,
float  regularizer = 0.0,
bool  enforceFloorInFirstFrame = false,
const std::string &  firstFramePoseConstraintSet = "",
float  targetHeightCm = 0.0f 
)

Use multiple frames to solve for global parameters such as body proportions and/or marker offsets together with the motion.

Parameters
[in]markerDataMarker data.
[in]characterCharacter definition.
[in]globalParamsBitset to indicate global parameters to solve for; could be all zeros for post-process a motion.
[in]initialMotionInitial values of all parameters. It should be the same length as markerData, but only frames used in solving are used. Values in unused frames do not matter. Number of parameters should be the same as defined in character.
[in]configSolving options.
[in]framesList of frames to solve for.
[in]enforceFloorInFirstFrameFlag to enforce the floor contact constraints in first frame
[in]firstFramePoseConstraintSetName of a pose constraint set to use for the first frame
Returns
The solved motion. It has the same length as markerData. It repeats the same solved pose within a frame stride.

◆ trackSequence() [4/4]

Eigen::MatrixXf momentum::trackSequence ( std::span< const std::vector< momentum::Marker > >  markerData,
const momentum::Character character,
const momentum::ParameterSet globalParams,
const Eigen::MatrixXf &  initialMotion,
const TrackingConfig config,
float  regularizer = 0.0,
size_t  frameStride = 1,
bool  enforceFloorInFirstFrame = false,
const std::string &  firstFramePoseConstraintSet = "",
float  targetHeightCm = 0.0f 
)

Use multiple frames to solve for global parameters such as body proportions and/or marker offsets together with the motion.

It can also be used to smooth out a motion with or without solving for global parameters, for example to fill gaps when there are missing markers.

Parameters
[in]markerDataMarker data.
[in]characterCharacter definition.
[in]globalParamsBitset to indicate global parameters to solve for; could be all zeros for post-process a motion.
[in]initialMotionInitial values of all parameters. It should be the same length as markerData, but only frames used in solving are used. Values in unused frames do not matter. Number of parameters should be the same as defined in character.
[in]configSolving options.
[in]frameStrideFrame stride to select solver frames (ie. uniform sample).
[in]enforceFloorInFirstFrameFlag to enforce the floor contact constraints in first frame
[in]firstFramePoseConstraintSetName of a pose constraint set to use for the first frame
Returns
The solved motion. It has the same length as markerData. It repeats the same solved pose within a frame stride.

◆ transformAtoB() [1/3]

template TransformT< double > momentum::transformAtoB ( size_t  jointA,
size_t  jointB,
const Skeleton referenceSkeleton,
const SkeletonStateT< double > &  skelState 
)

◆ transformAtoB() [2/3]

template TransformT< float > momentum::transformAtoB ( size_t  jointA,
size_t  jointB,
const Skeleton referenceSkeleton,
const SkeletonStateT< float > &  skelState 
)

◆ transformAtoB() [3/3]

template<typename T >
TransformT< T > momentum::transformAtoB ( size_t  jointA,
size_t  jointB,
const Skeleton referenceSkeleton,
const SkeletonStateT< T > &  skelState 
)

Computes the relative transform between two joints in a skeleton.

This transform maps points from joint A's local space to joint B's local space. It is computed by finding the common ancestor of both joints and combining the transforms along the path, which is more numerically stable than computing (T_B)^{-1} * T_A directly.

Parameters
jointASource joint index
jointBTarget joint index
referenceSkeletonThe skeleton structure defining joint hierarchy
skelStateCurrent state of the skeleton
Returns
Transform from joint A's local space to joint B's local space

Definition at line 188 of file skeleton_state.cpp.

References kInvalidIndex, and MT_CHECK.

◆ transformCharacter()

Character momentum::transformCharacter ( const Character character,
const Affine3f xform 
)

Transforms the character (mesh and skeleton) by the desired transformation matrix.

The transformation matrix should not have any scale or shear.

Note that this should primarily be used for transforming models between different coordinate spaces (e.g. y-up vs. z-up). If you want to move a character around the scene, you should preferably use the model parameters.

Parameters
[in]characterCharacter to be transformed
[in]xformTransformation to apply
Returns
A new Character object that has been transformed

Definition at line 424 of file character_utility.cpp.

References momentum::CharacterT< T >::blendShape, momentum::CharacterT< T >::collision, momentum::CharacterT< T >::faceExpressionBlendShape, momentum::CharacterT< T >::inverseBindPose, momentum::CharacterT< T >::locators, momentum::CharacterT< T >::mesh, momentum::CharacterT< T >::name, momentum::CharacterT< T >::parameterLimits, momentum::CharacterT< T >::parameterTransform, momentum::CharacterT< T >::poseShapes, momentum::CharacterT< T >::skeleton, and momentum::CharacterT< T >::skinWeights.

◆ transformPose() [1/6]

template std::vector< ModelParametersT< double > > momentum::transformPose ( const Character character,
const std::vector< ModelParametersT< double > > &  modelParameters,
const TransformT< double > &  transform 
)

◆ transformPose() [2/6]

template std::vector< ModelParametersT< float > > momentum::transformPose ( const Character character,
const std::vector< ModelParametersT< float > > &  modelParameters,
const TransformT< float > &  transform 
)

◆ transformPose() [3/6]

template<typename T >
std::vector< ModelParametersT< T > > momentum::transformPose ( const Character character,
const std::vector< ModelParametersT< T > > &  modelParameters,
const std::vector< TransformT< T > > &  transforms,
bool  ensureContinuousOutput = true 
)

Function which computes a new set of model parameters such that the character pose is a rigidly transformed version of the original pose.

While there is technically a closed form solution for any given skeleton, this is complicated in momentum because different characters attach the rigid parameters to different joints, so a fully general solution uses IK. However, getting it right requires dealing with local minima issues in Euler angles and other challenges. So centralizing this functionality in a single place is useful.

Parameters
[in]ensureContinuousOutputIf true, the output model parameters will be solved sequentially so that the resulting output is continuous where possible. This helps to avoid issues with Euler flipping.

Definition at line 229 of file transform_pose.cpp.

References MT_CHECK.

◆ transformPose() [4/6]

template<typename T >
std::vector< ModelParametersT< T > > momentum::transformPose ( const Character character,
const std::vector< ModelParametersT< T > > &  modelParameters,
const TransformT< T > &  transforms 
)

Definition at line 78 of file transform_pose.cpp.

References transformPose().

Referenced by transformPose().

◆ transformPose() [5/6]

template std::vector< ModelParametersT< double > > momentum::transformPose ( const Character characterFull,
const std::vector< ModelParametersT< double > > &  modelParametersFull,
const std::vector< TransformT< double > > &  transforms,
bool  ensureContinuousOutput 
)

◆ transformPose() [6/6]

template std::vector< ModelParametersT< float > > momentum::transformPose ( const Character characterFull,
const std::vector< ModelParametersT< float > > &  modelParametersFull,
const std::vector< TransformT< float > > &  transforms,
bool  ensureContinuousOutput 
)

◆ triangulate()

std::vector< Eigen::Vector3i > momentum::triangulate ( std::span< const uint32_t indices,
std::span< const uint32_t offsets 
)

Definition at line 17 of file polygon_data.cpp.

References MT_THROW_IF.

◆ trim() [1/4]

std::string momentum::trim ( const char text,
const char whiteChars = " \t" 
)

Returns a copy of the string from which all the characters in whiteChars at the beginning or at the end of the string have been removed.

Parameters
textThe string to trim (null-terminated)
whiteCharsA series of 1-byte characters to remove
Returns
The trimmed string

Definition at line 37 of file string.cpp.

References trim().

◆ trim() [2/4]

template std::string momentum::trim ( const std::string &  text,
const char whiteChars 
)

◆ trim() [3/4]

template std::string_view momentum::trim ( const std::string_view &  text,
const char whiteChars 
)

◆ trim() [4/4]

template<typename StringType >
StringType momentum::trim ( const StringType text,
const char whiteChars = " \t" 
)

Returns a copy of the string from which all the characters in whiteChars at the beginning or at the end of the string have been removed.

Template Parameters
StringTypeThe type of the string to trim (e.g., std::string, std::string_view)
Parameters
textThe string to trim
whiteCharsA series of 1-byte characters to remove
Returns
The trimmed string

Definition at line 16 of file string.cpp.

Referenced by parseParameterLimits(), parseParameterSets(), parseParameterTransform(), parsePoseConstraints(), tokenize(), tokenize(), and trim().

◆ twopi()

template<typename T = float>
constexpr T momentum::twopi ( )
constexprnoexcept

Definition at line 41 of file constants.h.

◆ uniform() [1/4]

template<typename T >
T momentum::uniform ( const T min,
const T max 
)

Generates a random type T from the uniform distribution, using the global random number generator Random.

Definition at line 322 of file random-inl.h.

References momentum::Random< Generator_ >::GetSingleton().

◆ uniform() [2/4]

template<typename DynamicMatrix >
DynamicMatrix momentum::uniform ( Eigen::Index  rows,
Eigen::Index  cols,
typename DynamicMatrix::Scalar  min,
typename DynamicMatrix::Scalar  max 
)

Generates a random type dynamic size matrix from the uniform distribution, using the global random number generator Random.

Definition at line 341 of file random-inl.h.

References momentum::Random< Generator_ >::GetSingleton().

◆ uniform() [3/4]

template<typename DynamicVector >
DynamicVector momentum::uniform ( Eigen::Index  size,
typename DynamicVector::Scalar  min,
typename DynamicVector::Scalar  max 
)

Generates a random dynamic size vector from the uniform distribution, using the global random number generator Random.

Definition at line 335 of file random-inl.h.

References momentum::Random< Generator_ >::GetSingleton().

◆ uniform() [4/4]

template<typename FixedSizeT >
FixedSizeT momentum::uniform ( typename FixedSizeT::Scalar  min,
typename FixedSizeT::Scalar  max 
)

Generates a random fixed size vector/matrix from the uniform distribution, using the global random number generator Random.

Definition at line 328 of file random-inl.h.

References momentum::Random< Generator_ >::GetSingleton().

◆ uniformAffine3()

template<typename T >
Affine3< T > momentum::uniformAffine3 ( T  scaleMin,
T  scaleMax,
const Vector3< T > &  min,
const Vector3< T > &  max 
)

Generates a random affine transformation from a uniform distribution on the space of all affine transformations.

Definition at line 368 of file random-inl.h.

References momentum::Random< Generator_ >::GetSingleton().

◆ uniformIsometry3()

template<typename T >
Isometry3< T > momentum::uniformIsometry3 ( const Vector3< T > &  min,
const Vector3< T > &  max 
)

Generates a random isometry (rigid transformation) from a uniform distribution on SE(3) based on input minimum and maximum 3D vectors for the translation part.

Definition at line 362 of file random-inl.h.

References momentum::Random< Generator_ >::GetSingleton().

◆ uniformQuaternion()

template<typename T >
Quaternion< T > momentum::uniformQuaternion ( )

Generates a random quaternion from a uniform distribution on SO(3)

Definition at line 351 of file random-inl.h.

References momentum::Random< Generator_ >::GetSingleton().

◆ uniformRotationMatrix()

template<typename T >
Matrix3< T > momentum::uniformRotationMatrix ( )

Generates a random rotation matrix from a uniform distribution on SO(3)

Definition at line 357 of file random-inl.h.

◆ updateAabb()

template<typename T >
void momentum::updateAabb ( axel::BoundingBox< T > &  aabb,
const Vector3< T > &  originA,
const Vector3< T > &  direction,
const Vector2< T > &  radii 
)

Updates an axis-aligned bounding box to encompass a tapered capsule.

Parameters
aabbThe bounding box to update
originAOrigin of the capsule
directionDirection vector of the capsule
radiiRadii at the endpoints of the capsule

Definition at line 112 of file collision_geometry_state.h.

Referenced by momentum::CollisionErrorFunctionT< T >::computeBroadPhase(), momentum::SimdCollisionErrorFunctionT< T >::computeBroadPhase(), logBvh(), momentum::CollisionErrorFunctionT< T >::updateCollisionPairs(), and momentum::SimdCollisionErrorFunctionT< T >::updateCollisionPairs().

◆ validateColumnIndices()

void momentum::validateColumnIndices ( std::span< const Eigen::Index >  colIndices,
Eigen::Index  maxEntry 
)

◆ verticesToFaces()

template<typename T >
std::vector< bool > momentum::verticesToFaces ( const MeshT< T > &  mesh,
const std::vector< bool > &  activeVertices 
)

Converts vertex selection to face selection.

Parameters
[in]characterCharacter containing the mesh
[in]activeVerticesBoolean vector indicating which vertices are active
Returns
Boolean vector indicating which faces only contain active vertices

Definition at line 1131 of file character_utility.cpp.

References momentum::MeshT< T >::faces, MT_CHECK, momentum::MeshT< T >::vertices, and verticesToFaces().

Referenced by reduceMeshByVertices(), and verticesToFaces().

◆ verticesToFaces< double >()

template std::vector< bool > momentum::verticesToFaces< double > ( const MeshT< double > &  mesh,
const std::vector< bool > &  activeVertices 
)

◆ verticesToFaces< float >()

template std::vector< bool > momentum::verticesToFaces< float > ( const MeshT< float > &  mesh,
const std::vector< bool > &  activeVertices 
)

◆ writeModelDefinition()

std::string momentum::writeModelDefinition ( const Skeleton skeleton,
const ParameterTransform parameterTransform,
const ParameterLimits parameterLimits 
)

Write complete model definition file.

Parameters
skeletonThe character's skeletal structure
parameterTransformMaps model parameters to joint parameters
parameterLimitsConstraints on model parameters (can be empty)
Returns
String containing the complete model definition

Definition at line 662 of file parameter_transform_io.cpp.

References momentum::ParameterTransformT< T >::name, momentum::ParameterTransformT< T >::parameterSets, parameterTransform, momentum::ParameterTransformT< T >::poseConstraints, skeleton, writeParameterLimits(), and writeParameterTransform().

◆ writeParameterLimits()

◆ writeParameterSets()

std::string momentum::writeParameterSets ( const ParameterSets parameterSets)

Definition at line 625 of file parameter_transform_io.cpp.

◆ writeParameterTransform()

◆ writePoseConstraints()

std::string momentum::writePoseConstraints ( const PoseConstraints poseConstraints)

Definition at line 645 of file parameter_transform_io.cpp.

Variable Documentation

◆ Dynamic

constexpr int momentum::Dynamic = Eigen::Dynamic
inlineconstexpr

Definition at line 41 of file types.h.

◆ kAllFrames

◆ kAvxAlignment

constexpr size_t momentum::kAvxAlignment = kAvxPacketSize * sizeof(float)
inlineconstexpr

Definition at line 33 of file simd.h.

◆ kAvxPacketSize

constexpr size_t momentum::kAvxPacketSize = 8
inlineconstexpr

Definition at line 32 of file simd.h.

◆ kDefaultExtrapolateFactor

constexpr float momentum::kDefaultExtrapolateFactor = 0.8f
inlineconstexpr

Definition at line 15 of file skeleton_utility.h.

◆ kDefaultExtrapolateMaxDelta

constexpr float momentum::kDefaultExtrapolateMaxDelta = 0.4f
inlineconstexpr

Definition at line 16 of file skeleton_utility.h.

◆ kInvalidIndex

constexpr size_t momentum::kInvalidIndex = std::numeric_limits<size_t>::max()
inlineconstexpr

Definition at line 200 of file types.h.

Referenced by momentum::CharacterT< float >::bakeBlendShape(), momentum::CharacterT< float >::bakeBlendShape(), calibrateModel(), momentum::SkeletonT< T >::commonAncestor(), momentum::FullyDifferentiableProjectionErrorFunctionT< T >::constraintGradient_dot(), momentum::FullyDifferentiablePosePriorErrorFunctionT< T >::d_gradient_d_input_dot(), momentum::PosePriorErrorFunctionT< T >::getBestFitMode(), momentum::GltfBuilder::getCharacterRootIndex(), momentum::SkeletonT< float >::getChildrenJoints(), momentum::SimdNormalErrorFunction::getGradient(), momentum::SimdCollisionErrorFunctionT< T >::getGradient(), momentum::PosePriorErrorFunctionT< T >::getGradient(), momentum::StateErrorFunctionT< T >::getGradient(), momentum::LimitErrorFunctionT< T >::getGradient(), momentum::CollisionErrorFunctionT< T >::getGradient(), momentum::CollisionErrorFunctionStatelessT< T >::getGradient(), momentum::JointToJointDistanceErrorFunctionT< T >::getGradient(), momentum::JointToJointPositionErrorFunctionT< T >::getGradient(), momentum::DistanceErrorFunctionT< T >::getGradient(), momentum::ProjectionErrorFunctionT< T >::getGradient(), momentum::FiniteDifferenceSequenceErrorFunctionT< T >::getGradient(), momentum::VelocityMagnitudeSequenceErrorFunctionT< T >::getGradient(), momentum::StateSequenceErrorFunctionT< T >::getGradient(), momentum::SimdCollisionErrorFunctionT< T >::getJacobian(), momentum::CollisionErrorFunctionT< T >::getJacobian(), momentum::CollisionErrorFunctionStatelessT< T >::getJacobian(), momentum::PosePriorErrorFunctionT< T >::getJacobian(), momentum::StateErrorFunctionT< T >::getJacobian(), momentum::LimitErrorFunctionT< T >::getJacobian(), momentum::JointToJointDistanceErrorFunctionT< T >::getJacobian(), momentum::JointToJointPositionErrorFunctionT< T >::getJacobian(), momentum::DistanceErrorFunctionT< T >::getJacobian(), momentum::ProjectionErrorFunctionT< T >::getJacobian(), momentum::FiniteDifferenceSequenceErrorFunctionT< T >::getJacobian(), momentum::VelocityMagnitudeSequenceErrorFunctionT< T >::getJacobian(), momentum::StateSequenceErrorFunctionT< T >::getJacobian(), momentum::SkeletonT< T >::getJointIdByName(), momentum::PosePriorErrorFunctionT< T >::getMeanShape(), momentum::GltfBuilder::getNumJoints(), momentum::ParameterTransformT< T >::getParameterIdByName(), momentum::SkeletonT< T >::isAncestor(), momentum::PosePriorErrorFunctionT< T >::loadInternal(), loadLocatorsFromBuffer(), loadPoseShape(), logJoints(), mapIdentityToCharacter(), mapMotionToCharacter(), mapMotionToCharacter(), mapParameters(), mapParameterTransformJoints(), momentum::SkinningWeightIteratorT< T >::next(), parameterLimitsFromJson(), parameterSetsFromJson(), parameterTransformFromJson(), parseParameterSets(), parseParameterTransform(), parsePoseConstraints(), poseConstraintsFromJson(), momentum::PoseTransformSolverT< T >::PoseTransformSolverT(), removeJoints(), replaceSkeletonHierarchy(), skeletonStateToJointParameters(), skeletonStateToJointParameters(), skeletonStateToJointParametersRespectingActiveParameters(), skeletonStateToJointParametersRespectingActiveParameters(), momentum::SkeletonT< T >::SkeletonT(), subsetParameterTransform(), and transformAtoB().

◆ kInvalidTexCoord

constexpr uint32_t momentum::kInvalidTexCoord = static_cast<uint32_t>(-1)
inlineconstexpr

Definition at line 15 of file polygon_data.cpp.

Referenced by momentum::PolygonData::warnMessage().

◆ kJacobianRowAlignment

constexpr size_t momentum::kJacobianRowAlignment = 8
inlineconstexpr

Alignment for SIMD operations on Jacobian rows (8 floats = 32 bytes for AVX).

Definition at line 19 of file solver_function.h.

Referenced by padToSimdAlignment().

◆ kJointParameterNames

constexpr std::array<const char*, kParametersPerJoint> momentum::kJointParameterNames {"tx", "ty", "tz", "rx", "ry", "rz", "sc"}
inlineconstexpr

◆ kMaxModelParams

constexpr size_t momentum::kMaxModelParams = 2048
constexpr

Definition at line 401 of file types.h.

Referenced by createLocatorCharacter().

◆ kMaxSkinJoints

◆ kMomentumMarkerProperty

constexpr const char* momentum::kMomentumMarkerProperty = "Momentum_Marker"
constexpr

Definition at line 22 of file openfbx_loader.h.

◆ kMomentumMarkersRootProperty

constexpr const char* momentum::kMomentumMarkersRootProperty = "Momentum_Markers_Root"
constexpr

Definition at line 21 of file openfbx_loader.h.

◆ kParametersPerJoint

constexpr size_t momentum::kParametersPerJoint = 7
inlineconstexpr

Definition at line 25 of file types.h.

Referenced by applyPassiveJointParameterLimits(), momentum::CharacterT< T >::bindPose(), momentum::ParameterTransformT< float >::computeActiveJointParams(), createLocatorCharacter(), momentum::SimdCollisionErrorFunctionT< T >::getError(), momentum::CollisionErrorFunctionT< T >::getError(), momentum::CollisionErrorFunctionStatelessT< T >::getError(), momentum::LimitErrorFunctionT< T >::getError(), momentum::StateErrorFunctionT< T >::getError(), momentum::SimdNormalErrorFunction::getGradient(), momentum::SimdCollisionErrorFunctionT< T >::getGradient(), momentum::StateErrorFunctionT< T >::getGradient(), momentum::LimitErrorFunctionT< T >::getGradient(), momentum::CollisionErrorFunctionT< T >::getGradient(), momentum::CollisionErrorFunctionStatelessT< T >::getGradient(), momentum::JointToJointDistanceErrorFunctionT< T >::getGradient(), momentum::JointToJointPositionErrorFunctionT< T >::getGradient(), momentum::FiniteDifferenceSequenceErrorFunctionT< T >::getGradient(), momentum::VelocityMagnitudeSequenceErrorFunctionT< T >::getGradient(), momentum::StateSequenceErrorFunctionT< T >::getGradient(), momentum::SimdCollisionErrorFunctionT< T >::getJacobian(), momentum::CollisionErrorFunctionT< T >::getJacobian(), momentum::CollisionErrorFunctionStatelessT< T >::getJacobian(), momentum::StateErrorFunctionT< T >::getJacobian(), momentum::LimitErrorFunctionT< T >::getJacobian(), momentum::JointToJointDistanceErrorFunctionT< T >::getJacobian(), momentum::JointToJointPositionErrorFunctionT< T >::getJacobian(), momentum::FiniteDifferenceSequenceErrorFunctionT< T >::getJacobian(), momentum::VelocityMagnitudeSequenceErrorFunctionT< T >::getJacobian(), momentum::StateSequenceErrorFunctionT< T >::getJacobian(), momentum::CharacterT< T >::initParameterTransform(), loadCharacterFromLegacyJsonString(), loadMmo(), logJointParams(), mapIdentityToCharacter(), mapMotionToCharacter(), mapParameterTransformJoints(), parameterLimitsFromJson(), parameterTransformFromJson(), parameterTransformToJson(), parseParameterTransform(), removeJoints(), replaceSkeletonHierarchy(), saveLocators(), saveMmo(), saveMmo(), skeletonStateToJointParameters(), skeletonStateToJointParameters(), skeletonStateToJointParametersRespectingActiveParameters(), skeletonStateToJointParametersRespectingActiveParameters(), momentum::CharacterT< float >::withFaceExpressionBlendShape(), writeParameterLimits(), and writeParameterTransform().

◆ kPositionWeight

◆ kSimdAlignment

◆ kSimdPacketSize

◆ kVelocityMagnitudeEpsilon

template<typename T >
constexpr T momentum::kVelocityMagnitudeEpsilon = T(1e-6)
inlineconstexpr

Epsilon for smooth velocity magnitude approximation: ||v||_smooth = sqrt(||v||^2 + eps^2)

This provides a smooth, differentiable approximation to the velocity magnitude with well-defined gradients even when velocity is near zero.

Definition at line 21 of file velocity_magnitude_sequence_error_function.h.

◆ RotationAxis

template<typename T >
const std::array<Vector3<T>, 3> momentum::RotationAxis
Initial value:
= {
Vector3<T>::UnitX(),
Vector3<T>::UnitY(),
Vector3<T>::UnitZ()}

Definition at line 20 of file joint_state.cpp.